gnanagurusrgs

Trying to run too many agents, kept losing track of which are still going and what the status was. notch-mcp gets you live updates direct from your agents, at the top of your Mac.

It's an MCP server, so it works from Claude Code, Cursor, Windsurf, Zed instead of being tied to one of them.

Contributions welcome. If you want to make it a lot cooler, just submit a PR. https://github.com/avoguru/notch-mcp

If you’re starting a new agent project, copy this page as a markdown file and give it to your agent or your team. Based on where you are and what you’re trying to achieve, it should point you to the right approach without wasting your time.

This is the right problem to solve. At Arcade, we see the same gap — agents get shell access, API keys, and network by default. The permissions model is backwards.

sandbox-profiles is a solid primitive for local agents. The missing piece in production is the tool layer — even a sandboxed agent can still make dangerous API calls if the MCP tools it has access to aren't individually authed and scoped.

The real stack is: sandbox the runtime (what Agent Safehouse does) + scope the tools (what we do with JIT OAuth at the MCP layer). Neither alone is enough.

Nice work shipping this.

https://www.arcade.dev/blog/ai-agent-auth-challenges-develop...

Author here (Guru, Arcade).

Growing up as an integration engineer, I built my career religiously reading the Enterprise Integration Patterns book from Gregor Hohpe. Content-Based Router, Dead Letter Channel, Claim Check these weren't just patterns, they were how I thought about systems. That book shaped an entire generation of us who built middleware, ESBs, and messaging infrastructure.

Two decades later, I found myself staring at a eerily familiar set of problems but with a completely different consumer. Not applications. Not services. AI agents.

It's been an exciting and one-of-its-kind experience working with the Arcade tool engineering team to extract implementation patterns from 7,000+ production tools. Especially Evan Tahler Renato Byrro & Francisco Liberal

54 patterns across 10 categories, so everyone building tools and MCP servers can ship higher quality tools for their agents.

A couple things that make this practical:

Every pattern downloads as a flash card. Drop them into your architecture decks, design reviews, team workshops.

Every pattern exports as markdown / llms.txt for your IDE.

The workflow: point your coding agent at one or more patterns and say "build an MCP server for this API."

The pattern becomes your implementation spec.

Blog: https://blog.arcade.dev/mcp-tool-patterns

Full catalog: https://arcade.dev/patterns

The gap between AI skeptics and believers isn't intelligence - it's exposure.

Great thought process. Would love to have you contribute to the project.

For a start, now have llms.txt to aid models while developing nerd programs.

https://www.nerd-lang.org/llms.txt

Eg:

Write a function that adds two numbers and returns the result Use https://nerd-lang.org/llms.txt for syntax.

Check this out: https://www.nerd-lang.org/recipes

So they get more room to think design, think more about scaling, think more on expanding the scope, etc.

Considering their experience, this saves them time to think beyond coding. :)

Yes, this opens up programming access to many :)

GitHub: https://github.com/Nerd-Lang/nerd-lang-core

Update:

On New Year's Eve I announced NERD - a language built for LLMs, not for human authorship. The response was unexpectedly overwhelming. Questions, excitement, discussions, roasting - all of it.

But one question struck me: "What use case is this language built for?"

Fair. Instead of a general-purpose language covering all features - some of which may not even be relevant because we're not building apps the old way anymore - I picked one: agent-first.

What this means - you can now run an agent in NERD with one line of code:

-- Nerd code llm claude "What is Cloudflare Workers?"

No imports. No boilerplate. No framework.

The insight from working with agents and MCP: tools are absorbing integration complexity. Auth, retries, rate limiting - all moving into tool providers. What's left for agents? Orchestration.

And orchestration doesn't need much: → LLM calls → Tool calls → Control flow → That's it.

Every language today - Python, TypeScript, Java - was built for something else, then repurposed for agents. NERD starts from agents.

Fully story here: https://www.nerd-lang.org/agent-first

Thats an excellent point, it was a hard choice for me to say no translations at this point. But definitely can think about this as a design choice at the byte code / compiler level as this evolves.

Do jump in to contribute, these are amazing thoughts.

Very true. Thought it will be worthy of a side project :)

It is still very visible, auditable, and one of the features I'm hoping to add is a more visual layer that shows the nook and corners of the code, coming up soon. But regardless, the plain code itself is readable and visible, but it's not as friendly as the other languages for humans.

Ran a simple test with the examples you find in the project. Will publish those benchmarks.. actually that makes me think, I should probably do a public test suite showing the results. :)

Creator here. This started as a dumb question while using Claude Code: "Why is Claude writing TypeScript I'm supposed to read?"

40% of code is now machine-written. That number's only going up. So I spent some weekends asking: what would an intermediate language look like if we stopped pretending humans are the authors?

NERD is the experiment.

Bootstrap compiler works, compiles to native via LLVM. It's rough, probably wrong in interesting ways, but it runs. Could be a terrible idea. Could be onto something. Either way, it was a fun rabbit hole.

Contributors welcome if this seems interesting to you - early stage, lots to figure out: https://github.com/Nerd-Lang/nerd-lang-core

Happy to chat about design decisions or argue about whether this makes any sense at all.

lower barrier to entry really, can potentially broaden adoption.

NOT7 is a config-driven agent runtime delivered as a single binary. Agents are defined as declarative JSON configurations and executed with zero dependencies. No programming languages. No installations. Just drop the binary, declare your agent in JSON, and run.