Briefing
A few years ago, building a real AI product meant signing up for someone else's platform, paying per request, and hoping the vendor didn't change the rules halfway through your roadmap. That's no longer the trade-off. By 2026, the free and community-built side of the AI world has caught up to the point where you can train a model, wire up an agent, ship the app, and watch it run in production without paying a single licence fee.
For an Australian business team, that shift matters in a practical way. It means the difference between a monthly bill that scales with every customer and a setup that mostly costs you the hardware it runs on. It means your customer data can stay on your own machines instead of being shipped offshore through an API. And it means that when a tool you depend on changes its pricing, you're not held hostage by it.
This is a walk through the full open-source AI stack as it stands in 2026, ten layers, from the model itself down to how you deploy and monitor it. Where the numbers come from real, checkable sources, I've linked them. Where a figure is more of a back-of-the-envelope estimate or a claim I couldn't pin down, I've said so plainly. No tool here requires a credit card to get started.
Layer 1: Foundation Models and Training
Training Frameworks
nanochat (55,000 stars), Andrej Karpathy's stripped-back LLM training stack (karpathy/nanochat on GitHub). You can train a GPT-2 class model for about $48 (nanochat discussion: Beating GPT-2 for <$100). It's built for learning and tinkering rather than shipping, and on that count it's hard to beat.
DisTrO (Nous Research), Distributed training that runs over ordinary internet connections, cutting inter-GPU chatter by a reported 857x and later forming the basis of the Psyche network (VentureBeat on Nous Research DisTrO). It's more precisely a distributed-training optimiser than a full orchestration system, and the descriptions of heterogeneous-hardware support, fault tolerance, and dynamic scaling are loose characterisations rather than confirmed features. The point stands, though: it's a way to train without a supercomputer budget.
PyTorch + Transformers, The default choice for most people. Hugging Face's Transformers library ships pre-trained models and training scripts for every major architecture you're likely to touch.
Model Weights
Hugging Face Hub: More than 500,000 model weights are there for the downloading, and that's a conservative count, with the Hub actually hosting well over 2 million models by mid-2026 (Hugging Face's two million models and counting). Llama, Mistral, Qwen, and a long tail of domain-specific models are all on the Hugging Face model hub.
LocalAI Model Gallery: A curated set of optimised models packaged for local deployment.
Layer 2: Local Inference
LocalAI (44,000 stars), An OpenAI-compatible API you run yourself (mudler/LocalAI on GitHub). It handles LLMs, vision models, embeddings, diffusion, and audio on whatever hardware you've got. If you need API compatibility in production, this is the one to reach for.
Ollama, The developer-friendly local runner (Ollama). It has the best command-line experience of the bunch and is well tuned for Mac. Good for development and quick experiments.
llama.cpp, The C++ inference engine doing the heavy lifting under most local deployments, with bindings for just about every language (llama.cpp on GitHub). Ollama and LocalAI both lean on it.
vLLM, High-throughput serving built around PagedAttention. Worth it when request volume is high and latency matters.
Layer 3: Agent Frameworks
OpenClaw (345,000 stars), A skills-based agent framework with 100+ built-in skills, the ClawHub marketplace, and a Node.js foundation. It's reportedly overtaken React as GitHub's most-starred project, with the 345,000 figure matching coverage from April 2026 (OpenClaw statistics). The pick for JavaScript developers who want broad capability out of the box.
Hermes Agent, A self-improving learning agent built on Honcho dialectic memory, listing 40+ tools (NousResearch/hermes-agent on GitHub). The article's original "22,000 stars" figure looks well off, the live repo shows closer to 197,000, and the "142 contributors" claim couldn't be confirmed, so treat both numbers with caution. It's the natural choice for Python developers building personalised assistants.
AutoGen, Microsoft's multi-agent orchestration, with code execution and human-in-the-loop built in (microsoft/autogen on GitHub). A sensible fit for enterprise teams already living in the Microsoft ecosystem.
CrewAI, The most approachable multi-agent framework, organised around role-based agents. A good starting point if multi-agent systems are new to you.
MetaGPT, Multi-agent software development teams, aimed squarely at code generation and engineering tasks.
Layer 4: Visual Development
Langflow (146,000 stars), A drag-and-drop agent builder with 100+ components and full code export (langflow-ai/langflow on GitHub). The 146,000 figure sits within the range reported through mid-2026, though the exact component count wasn't independently confirmed. Best for fast prototyping and no-code work.
Dify (136,000 stars), A full LLM app platform with visual orchestration, a RAG pipeline, and one-click deployment (Dify 2026 overview). Built for shipping production applications.
Layer 5: Memory and Context
Mem0 (52,000 stars), A model- and framework-agnostic memory layer combining vector, graph, and key-value storage (mem0ai on GitHub). Note the numbers are a touch optimistic: star counts mid-2026 cluster nearer 47,000-48,000, and the "sub-50ms retrieval" latency claim wasn't independently confirmed. Still, it's the default many teams reach for when an agent needs to remember things.
Honcho, The dialectic memory system behind Hermes Agent, built for user modelling and personalisation (Hermes Agent Honcho memory README).
OpenHuman Memory Trees, A hierarchical knowledge system for desktop AI, pitched at personal knowledge management.
Layer 6: Web and Browser Tools
Firecrawl (130,000+ stars), A web context API that turns any site into clean Markdown (firecrawl/firecrawl on GitHub). It's a top-tier GitHub repo and close to essential for any agent that needs to read the web.
Browser-use (86,000 stars), Browser automation driven by plain language, suited to multi-step web tasks. The star figure looks inflated; reporting in 2026 puts it nearer 78,000 (Browser Use on GitHub).
Vercel agent-browser (27,000 stars), Serverless browser automation, handy for Vercel-hosted apps (vercel-labs/agent-browser on GitHub). If anything the count understates it, the live repo shows around 36,400 stars.
Layer 7: Development Tools
awesome-claude-skills, A community-curated set of 1,000+ production-ready skills for Claude Code.
LobeHub, A multi-agent chat UI with deep customisation.
Pi Coding Agent, A Claude Code competitor with its own take on agent-assisted development. Details on it remain unconfirmed, so treat the framing as reported rather than tested.
Layer 8: Security and Safety
Bumblebee (Perplexity), A supply-chain security scanner for AI projects, open-sourced by Perplexity on 22 May 2026 (Perplexity blog: Open-Sourcing Bumblebee). It's a read-only Go tool that reads lockfiles and covers npm, PyPI, MCP configs, VS Code extensions, and browser extensions.
Atropos (Nous Research), A model evaluation framework (NousResearch/atropos on GitHub). To be precise, it's a reinforcement-learning environments framework for collecting and scoring LLM trajectories; the "adversarial testing" label is a stretch on its actual stated purpose.
OWASP AI Security, Open security standards for AI applications.
Layer 9: Monitoring and Observability
LangSmith, Observability for LangChain and Langflow apps. Trace execution and keep an eye on performance.
OpenTelemetry + Prometheus, The industry-standard pairing for tracking latency, throughput, errors, and cost.
Grafana, Visualisation and alerting on top of your AI metrics.
Layer 10: Deployment and Infrastructure
Docker + Kubernetes, Container orchestration for AI deployments that need to scale.
BentoML, A model-serving framework with auto-scaling and A/B testing.
Tauri, A Rust-based desktop framework (tauri-apps/tauri on GitHub). It's reportedly used by OpenHuman for lightweight AI apps, though that specific usage couldn't be independently verified.
A Complete Stack Example
Here's how the pieces fit together for a production research assistant:
- Training: Fine-tune a model with PyTorch + Transformers, or grab a pre-trained one from Hugging Face.
- Inference: Serve it with LocalAI for OpenAI API compatibility.
- Agent: Build the agent with OpenClaw or Hermes, depending on whether you're a JS or Python shop.
- Memory: Bolt on Mem0 for persistence.
- Web Access: Add Firecrawl so the agent can browse.
- Visual Interface: Build the UI in Langflow, or write it by hand.
- Security: Run Bumblebee in CI to check your dependencies.
- Monitoring: Wire up LangSmith tracing and Prometheus metrics.
- Deployment: Ship it with Docker on whatever infrastructure you prefer.
Cost Comparison
Open-source tooling works out far cheaper than the proprietary route. The one hard figure here is nanochat's ~$48 training cost (nanochat); the rest of these ranges are editorial estimates that swing with your scenario, not sourced facts, so read them as ballpark rather than quote:
- Training: $48 (nanochat) vs $10,000+ (cloud training)
- Inference: hardware cost only (LocalAI/Ollama) vs $0.01-0.10 per request (API)
- Agent Framework: free (OpenClaw/Hermes) vs $100-500/month (proprietary platforms)
- Memory: free (self-hosted Mem0) vs $50-200/month (managed services)
- Web Access: free (self-hosted Firecrawl) vs $50-500/month (managed services)
Roughly, a production research assistant might run you $100-500/month in hardware against $1,000-5,000/month in API fees and platform costs. Those numbers are illustrative, but the gap is real.
The Maturity Question
The usual pushback on open-source AI stacks is that they're not mature enough for serious work. The star counts argue otherwise:
- OpenClaw: ~345,000 stars, reportedly used by Fortune 500 companies
- Langflow: ~146,000 stars, with enterprise deployments around the world
- Dify: ~136,000 stars, running production apps across industries
- LocalAI: ~44,000 stars, powering production inference
These aren't weekend experiments. They're infrastructure that real organisations are betting on.
Getting Started
If you're building an AI system in 2026, the open-source stack is a fine place to start:
- Pick an agent framework, OpenClaw for JS, Hermes for Python.
- Add memory with Mem0.
- Add web access with Firecrawl.
- Choose your inference, LocalAI for production, Ollama for dev.
- Deploy with Docker.
- Monitor with Prometheus + Grafana.
The tools are ready and the community is active. What you build with them is up to you.