It started out as a cloud runner for small (mostly pure) composable javascript functions that we run for you in the cloud. So whenever you have some small code snippet that you want to run, you can hit up microfn.dev, paste your code and then plug it into wherever you want (pipe into the terminal, use from MCP, add a cron to it, add to Siri shortcuts, use for home automation, ping it with webhooks, etc)
Now we added agents support, so you can have autonomous AI agents take your functions and decide when to use them. Even better, you can hook microfn into a MCP and have anything that supports MCP use those functions as well!
Suppose you need a new thing that your agent should do, you could ask the agent (whether that's claude or cursor) to compose a new function, add it to microfn, then use it itself going forward!
microfn.dev wants to be a toolbox for composable small tools. Imagine a toolbox at home with a bunch of hammers and screw drivers that you collect, share, and use for different purposes.
Some actual examples:
- Pull data off services (twitter, etc)
- Store data from sensors somewhere
- Give agents tools to talk to your specific systems without needing to write an entire MCP
- Wrap complex logic (eg slack auth + sending a message to slack) into a function and add it to a Siri shortcut, so you can quickly send messages to a specific channel with a ping or curl
Still very early alpha (beta-ish), but very excited about this
A buddy and me have been working on https://microfn.dev for a while: A platform for creating, managing and composing tiny (micro) javascript functions and using them from different places like webhooks, cron, MCP or AI agents.
It's still very heavy in development but the gist is: Say you have a cool idea for something small you want to automate or run - instead of thinking about hosting, workers, lambdas and what not, you just open microfn, open the editor (or the function generator), write your function, hit save - done! All the complexity is tucked away on microfn, and your place of use just has to authenticate with microfn and nothing else. We run it for you and keep you productive.
Now you can use that function from anywhere: From the terminal, periodically with a cron, add it to an AI agent as skill, use it through an MCP (not released yet), through Siri shortcuts, share it with your friends and so on.
Say you want to have an agent or function that gets the weather and sends it through Telegram: You can either quickly generate 2 functions through the AI function generator that get the weather ("I want a function that gets the weather for Tokyo") and another one for sending a message on telegram, or you can use what's already available (such as https://microfn.dev/david/getweathertokyo). Equipping them to an agent works like in a video game - each function is a new "skill" or "tool" the agent can use, and if someone else already has some cool skills, you can fork them without needint to re-implement everything from scratch.
So like a toolbox full of small composable hammers and tools that can be used across different scenarios and places, to be plugged into existing workflows, automation or to even be used in autonomous agents and through MCP.
Again, super heavy in development and not really a 1.0 yet, more like an early alpha, but wanted to share here anyway. Feedback greatly appreciated!
Sounds neat, but please make testing first class - it should be easy to run functions locally, or to have the same code "infrastructure" run in dev/test/prod environments, etc
Love this, and love that you're using Elixir LiveView as well as Elixir with the Slack bot and lastly that you're based in Tokyo.
Followed you on Github, I'm looking at moving (back) to Japan in two years, likely to start a bootstrapped startup business and always good to have dev friends!
I blog about random bits and blobs in tech. Sometimes a review, sometimes trying out something new. Wanted to try and keep it interesting and not too fixated on one category.
Background was that we wanted to explore providing access to ChatGPT to employees at $company, but restrict access with Google OAuth using company email, and use the company OpenAI API key on the back. So I hacked together something quick that matches our requirements and we can self-host.
funny timing, just yesterday I finished a little app I was hacking on and needed a somewhat decent looking logo that was blocking the release.
Instead of trying my luck in sketch and doodling around, I went to DALL E, and with my first prompt was able to generate better logos than I could have drawn. I was immediately unblocked and super happy with the results
It’s just amazing that non design people like me can just conjure up decent looking, and usable stuff with AI. I will definitely use DALL E much more going forward for creative work
The logos are a bit noisy and need redrawing in a proper vector tool but its a great starting point to try out different ideas immediately
I keep IPFS companion turned on constantly but when I hit a site that's getting loaded through IPFS it often takes so long that I end up turning IPFS off so it just fetches it from the central server
Small composable packages aren’t a bad thing IMO. It’s nice to pull things together how you want without having to reimplement the same logic multiple times. Just encapsulate smaller bits of useful code into their own mini packages
Like if there’s some string manipulation thing I need, instead of copy pasting some snippet, I can pull in the micro package that already does this
I'm going to have to disagree with that. Micropackages may seem nice at first, but they're a nightmare to manage longer-term mostly due to low-skill project management. Many such packages make breaking API changes, sometimes without obeying SemVer standards. Some are effectively abandoned, and don't get updates for regular bugs, security issues, etc. Sometimes the lone developers responsible for them may delete them in a fit of pique (left-pad anyone?). Sometimes they get taken over by malicious entities who might add obvious or subtle malware to it. I'm pretty sure all of these have happened already.
That's not even what's important though. What's important is, how can you ensure that none of these things happen to any of *your* projects dependencies? It's virtually impossible when there's a thousand of them. Are you going to audit that string manipulation micro package when you first add it, and then for every version update from now on, to ensure that nobody slipped some subtle malicious code into it? And do the same for every other micro package in your project, including all of the ones that the big ticket packages depend on?
All of this would be much less relevant if it had a more fully-featured standard library.
makes sense in some situation but people seems to forget left pad fiasco. And the small package which you say sounds good in theory but what we get is bloated things that depends on multiple semver package. And many developers don't even have a clue whats happening which algorithm it is using and thats fair if you get millions package in nested dependencies.
However in Rust I find these packages managed properly which npm should learn.
The thing is, many other modern ecosystems have these included. You don't need a pile of dependences because you are guaranteed to have the functionality you need. Of course you will still need modules for more specific things but since the most often used functionality is already there you end up with ten packages, not a hundred or more.
It started out as a cloud runner for small (mostly pure) composable javascript functions that we run for you in the cloud. So whenever you have some small code snippet that you want to run, you can hit up microfn.dev, paste your code and then plug it into wherever you want (pipe into the terminal, use from MCP, add a cron to it, add to Siri shortcuts, use for home automation, ping it with webhooks, etc)
Now we added agents support, so you can have autonomous AI agents take your functions and decide when to use them. Even better, you can hook microfn into a MCP and have anything that supports MCP use those functions as well!
Suppose you need a new thing that your agent should do, you could ask the agent (whether that's claude or cursor) to compose a new function, add it to microfn, then use it itself going forward!
microfn.dev wants to be a toolbox for composable small tools. Imagine a toolbox at home with a bunch of hammers and screw drivers that you collect, share, and use for different purposes.
Some actual examples:
- Pull data off services (twitter, etc)
- Store data from sensors somewhere
- Give agents tools to talk to your specific systems without needing to write an entire MCP
- Wrap complex logic (eg slack auth + sending a message to slack) into a function and add it to a Siri shortcut, so you can quickly send messages to a specific channel with a ping or curl
Still very early alpha (beta-ish), but very excited about this