Atlas / MCP servers / sema-lisp / Sema

SemaBLOCK

Name: Sema
Author: sema-lisp

mcp/sema-lisp/sema-1

MCP server by sema-lisp · agentic ai · agents · ai · Audited 2026-10-08

⚑ Report / re-scan Source ↗

A Lisp with first-class LLM primitives, implemented in Rust

Verdict

BLOCK

Grade

Trust score

32 /100

Exposed tools

17 9r · 7w · 1d

Transport

stdio · streamable-http

License

MIT

Stars

Overview

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

A Lisp where LLM agents are language primitives, not an SDK — compiled to a fast bytecode VM, shipped as a single binary.

[](https://sema.run) [](https://sema-lang.com/docs/) [](https://github.com/sema-lisp/sema/releases/latest) [](https://codecov.io/gh/sema-lisp/sema) [](LICENSE)

**Docs** · **Playground** · **For Agents** · **Examples** · **Issues**

Stop rewriting the agent loop. Every LLM script grows the same scaffolding — retries, caching, cost caps, rate limits, tool dispatch, conversation state. Sema makes that scaffolding the runtime: your script stays the size of its idea, ships as a single binary, and your coding agent already speaks the language.

Sema is a Scheme-like Lisp where prompts are s-expressions, conversations are persistent data structures, and LLM calls are just another form of evaluation — with Clojure-style keywords (:foo), map literals ({:key val}), and vector literals ([1 2 3]).

What It Looks Like

A coding agent with file tools, safety checks, and budget tracking — in ~40 lines:

;; Define tools the LLM can call
(deftool read-file
"Read a file's contents"
{:path {:type :string :description "File path"}}
(lambda (path)
(if (file/exists? path) (file/read path) "File not found")))

(deftool edit-file
"Replace text in

Read from source at commit 9f8c1a173cd8OBSERVED · 2026-10-08

Connect

Built from this server's own package name, version and transport as found in its source — not copied from anyone's documentation, so it cannot drift against a page we do not control. Replace the environment placeholders with a token scoped to the least it needs.

claude-code

claude mcp add sema-website --env ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY} --env OPENAI_API_KEY=${OPENAI_API_KEY} -- npx -y sema-website

claude-desktop

{
  "mcpServers": {
    "sema-website": {
      "command": "npx",
      "args": [
        "-y",
        "sema-website"
      ],
      "env": {
        "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}",
        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
      }
    }
  }
}

Exposed tools (17)

9 read · 7 write · 1 destructive. Blast radius: 1 tool can delete or overwrite — an agent that can be talked into calling a tool can be talked into calling this one.

Tool	Risk	Description
`continue_debugging`	read	Continue the paused Sema debugger and wait for the next breakpoint, finish, or error.
`find_examples`	read	Find bundled Sema examples by filename, category, or identifier. Returns identifiers accepted by load_example.
`format_editor`	write	Format and replace the current Sema source in the editor. This does not run the code.
`get_debug_state`	read	Read debugger status, active line, breakpoints, locals, and stack frames.
`list_files`	read	List the immediate children of one virtual filesystem directory. The listing is non-recursive.
`load_example`	read	Replace the editor with one bundled Sema example selected by identifier or filename. This does not run the code.
`read_editor`	read	Read Sema source from the playground editor. Use this before editing or running unfamiliar code.
`read_file`	read	Read a character range from a UTF-8 text file in the playground virtual filesystem.
`read_output`	read	Read the current playground output, including values, printed lines, errors, and timing.
`run_editor`	write	Run the current Sema source, using the worker runtime when available, and wait for evaluation to finish.
`set_breakpoints`	write	Replace all debugger breakpoints with one-based lines, snapping requests to executable source lines.
`start_debugging`	write	Start debugging the current Sema source and wait for a pause, finish, or error.
`step_debugger`	read	Step the paused Sema debugger into, over, or out, then wait for its next stable state.
`stop_debugging`	write	Stop the active Sema debugger and return the playground to its idle state.
`stop_run`	write	Cancel the active worker-backed Sema evaluation when one is running.
`write_editor`	write	Replace the entire playground editor with Sema source. This does not run the code.
`write_file`	destructive	Create or overwrite a UTF-8 virtual file, creating parent directories as needed. Content is limited to 1 MiB.

Trust audit

BLOCKgrade F · trust 32/100 Do not install this without reading the findings. The audit found something that could harm you or your machine.

Layer	What it checks	Result
L0	Provenance & inventory	PASS
L1	Static analysis of the code	FAIL
L2	Instruction surface (what it tells the agent)	WARN
L3	Class-specific surface	WARN
L4	Behavioural (sandbox)	SKIPPED

What the source does

Filesystem: declared (8 observation(s))
Network: declared (14 observation(s))
Shell: declared (5 observation(s))
Dependencies: not all pinned
Secrets in source: found

Findings (25)

CRITICALHard-coded secrets · secret.github · CWE-798, CWE-321

crates/sema-stdlib/src/secret.rs:412

let gh = "ghp_0000000000000000000000000000000000000000";

CRITICALHard-coded secrets · secret.private_key · CWE-798, CWE-321

crates/sema-stdlib/src/secret.rs:416

let pk = "-----BEGIN RSA PRIVATE KEY-----";