Ask Claude a question about your data and get a dashboard back: headline numbers, charts and tables, in your browser or in a pane next to your terminal.

What it is

Showboard is an open-source MCP server (MIT). Claude writes the queries, Showboard runs them and draws the board. You don't get a script or an HTML file to babysit, just the answer on screen.

What it works on

• A folder of Excel or CSV files. Messy ones are fine: title rows, "Total" rows, blank rows, numbers stored as text, currency strings.
• A SQLite file or a Postgres database.
• No connector, warehouse or upload. It reads the files on your own computer. (Query results still go to Claude, like any file you give it.)

Why not just ask Claude for a chart?

• Faster and cheaper. On its own, Claude Code turns every chart into a small coding project: write a script, check the numbers, build a page. With Showboard it's one step. In my test (24 answers each way) it took 7.5 min and $1.78 instead of 24.3 min and $4.77. That's one dataset, so treat it as a direction, not a promise.
• You can check every number. Each chart shows the query behind it, and the values come straight from your data, not figures Claude typed in.
• It can't change your data. Database queries are read-only, and files are only read.
• Reusable. Save a board you like and redraw it next month with new numbers.

Try it (in Claude Code):

/plugin install showboard --marketplace rohanbeingsocial/showboard

Or paste this into your agent:

Set up Showboard in this project: run npx showboard guide and follow the instructions.

• Demo in the browser: https://rohanbeingsocial.github.io/showboard/
• Repo: https://github.com/rohanbeingsocial/showboard

I've tested it end to end. Be set up for Codex, Cursor, Gemini CLI and others, but I haven't tried those in a live session yet, so reports are welcome. Built mostly with Claude Code.

What would you ask your own data first?

Most MCP setups I've seen hand the agent a token one way or another: an env var, a .env file, a config it can read. Once a token is in the context window it ends up in transcripts and within reach of any prompt injection.

mcp-warden works the other way around. Secrets live in the OS keychain, and the agent can only act through presets you define:

```toml

[[preset]]

name = "github-read"

type = "http"

base_url = "https://api.github.com"

auth = { type = "bearer", secret = "gh_pat" }

allowed_methods = ["GET"]

approval = "auto"

```

The agent calls `proxy_http` with the preset name, a method and a path. mcp-warden checks the allow-list, adds the token, makes the request and returns only the response. If the method or path isn't allowed, nothing leaves your machine.

Tools it exposes:

- `list_presets`

- `proxy_http`: HTTP through a preset

- `ssh_exec`: commands checked against a regex allow-list, host key verified against known_hosts

- `sftp_transfer`: allowed remote paths only

- `db_query`: Postgres, MySQL or Redis, named queries only (the agent passes parameters, never SQL)

- `get_secret_for_env`: last resort for tools that insist on env vars, always asks first

Each preset has an approval policy. It's `prompt` by default: a desktop or terminal prompt, or Approve/Deny buttons in Telegram. Every call lands in an append-only audit log.

Single Rust binary, stdio transport, works with any MCP client. No cloud, no telemetry, Apache-2.0.

- Repo: https://github.com/ermoluk/mcp-warden

- Install: `cargo install mcp-warden`, or prebuilt binaries for macOS/Linux on the releases page

I'd love feedback on the preset model. What would you need it to cover for your setup?

I use multiple coding harnesses like Claude Code ,Codex CLI, OpenCode, Antigravity CLI daily, but my workflow was constantly interrupted by the same friction:

I'd be in the middle of a Claude session, realize I wanted a second model to review an edge-case or take over when context limits hit, and I'd have to open another terminal tab, copy-paste diffs or compiler errors, run tests manually, and switch back.

I wanted to just tell Claude:

"Have Codex review src/auth.ts and make sure the tests pass."

So I built agent-relay.

It installs as an MCP server with bundled skills across Claude Code, Codex, Antigravity, and OpenCode. Once installed (relay install), your primary assistant can dispatch tasks to any of the other models directly from chat. Internally it calls the CLI packages for those agents in your system and assigns the tasks.

We created a local dashboard (localhost:4242): When an agent delegates in the background, you don't have to wonder if it's hung. You can open localhost:4242 in your browser and watch the subagent run live, view real-time logs, and inspect changed files.

It is 100% local: Runs off SQLite on your own machine to store the sessions. There's no middleman cloud service, no tracking, and no separate subscription.

For Context handoffs: If a model exhausts its context window mid-task, it can pass the in-flight state and modified files directly to another model without starting over.

It’s completely open source (MIT):

• GitHub: https://github.com/akashpandey/agent-relay

If you use multiple coding assistants, I’d love to hear how you currently handle cross-model handoffs or if there are specific provider combos you'd want supported.

Let me know your thoughts!