Skip to content

From Libraries to Capabilities

Software development is changing. CmdForge is our attempt to make it simpler, more composable, and accessible to everyone.

The Journey

I first learned to code on a Commodore VIC-20, writing BASIC before DOS existed. I've watched computing evolve through every major shift: from single programs to functions, from functions to libraries, from libraries to frameworks, from frameworks to microservices.

Each evolution promised to make things easier. And in many ways, they did. But something else happened too: fragmentation.

Open source gave us everything we could ever want. Thousands of contributors building solutions to every problem imaginable. But finding the right solution became the problem itself.

The Problem

Traditional Development

"Like digging through a giant bin of tangled circuits..."

  • Thousands of libraries to evaluate
  • Different philosophies and coding styles
  • Version conflicts and dependency hell
  • Reinventing the same solutions

The CmdForge Way

Text Developer

"Like an organized workshop with a knowledgeable shopkeeper..."

  • Every tool has a clear purpose
  • AI helps you find what you need
  • Tools combine instantly
  • Shared globally, improved together

The Insight

What if we stopped thinking about libraries and started thinking about capabilities?

A library is code you integrate. A capability is something you ask for.

Instead of searching through npm, pip, or crates.io for the right package, what if you could just describe what you need?

"I need something that extracts key points from meeting transcripts."

And the system either finds an existing tool that does exactly that, or creates one for you—and shares it back so the next person doesn't have to ask.

The System

Ask for what you need. CmdForge finds it, composes it, or creates it. 

flowchart TD
    User["👤 Developer / System"]
    AI["🤖 CmdForge AI Assistant"]

    Registry["📦 Tool Registry"]
    Tool1["🔧 Tool: Parse CSV"]
    Tool2["🔧 Tool: Send Email"]
    Tool3["🔧 Tool: Query API"]

    NewTool["✨ Generated Tool"]

    User --> AI
    AI --> Registry

    Registry --> Tool1
    Registry --> Tool2
    Registry --> Tool3

    AI -->|Compose Tools| Execution["⚙️ Execution Pipeline"]

    AI -->|If missing| NewTool
    NewTool --> Registry

    Execution --> Result["✅ Result"]
    Result --> User

How It Works

Tools Compose Into Systems

Input
meeting.txt
Tool
extract-topics
Tool
summarize
Tool
format-email
Output
summary.md

Each tool does one thing well. Combined, they create complex workflows.

Ask, Don't Search

Describe what you need in natural language. AI finds or creates it.

cmdforge registry describe "analyze sentiment"

Compose, Don't Integrate

Tools chain together with Unix pipes. No dependency management.

cat data.csv | analyze | report

Share, Don't Hoard

Every tool you create can benefit others. Build on each other's work.

cmdforge registry publish

The Belief

"If something has been built once, it should be reusable forever.

Not as a library. Not as a framework.
But as a capability anyone can call."

Composable By Design

Tools can call other tools. Complex systems emerge from simple parts. 

flowchart LR
    A["Tool A"] --> B["Tool B"]
    B --> C["Tool C"]
    A --> D["Tool D"]

    subgraph Composable System
        A
        B
        C
        D
    end

Future Vision

Tools shared across machines. Distributed capabilities for distributed systems. 

flowchart LR
    Node1["🖥️ Node A"]
    Node2["🖥️ Node B"]
    Node3["🖥️ Node C"]

    ToolA["🔧 Tools"]
    ToolB["🔧 Tools"]
    ToolC["🔧 Tools"]

    Node1 --> ToolA
    Node2 --> ToolB
    Node3 --> ToolC

    Node1 <-->|Call Tools| Node2
    Node2 <-->|Call Tools| Node3
    Node1 <-->|Call Tools| Node3

Coming soon: Expose tools over a port for distributed execution across your infrastructure.

Proof of Concept

Orchestrated Discussions: A complete multi-agent AI system built entirely from CmdForge tools.

Orchestrated Discussions

21 tools working together

Multiple AI personas debate topics, vote on outcomes, and synthesize conclusions. The entire system is built from small, focused CmdForge tools that call each other.

21
Composable Tools
0
External Dependencies
View Collection
Example flow: Multi-agent debate
discussion-start → topic
persona-respond × 5
vote-collect
consensus-check
discussion-summarize → output

This is what "composable capabilities" looks like in practice.

Before vs After

The same task: summarize a document and email the key points.

1

Traditional Approach

# Step 1: Install dependencies
pip install openai python-dotenv smtplib

# Step 2: Write the code (40+ lines)
import os
import smtplib
from openai import OpenAI
from email.mime.text import MIMEText

client = OpenAI(api_key=os.getenv("OPENAI_KEY"))

def summarize(text):
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user",
            "content": f"Summarize: {text}"}]
    )
    return response.choices[0].message.content

def send_email(to, subject, body):
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['To'] = to
    # ... 15 more lines of SMTP setup

# Step 3: Handle errors, env vars, etc.
40+ lines, API keys, dependencies, error handling
2

CmdForge Approach

# Option A: Unix pipes
cat document.txt | summarize | send-email

# Option B: Compose into a new tool
name: doc-to-email
steps:
  - tool: summarize
    output_var: summary

  - tool: send-email
    input_template: "{summary}"

# Now use it:
cat document.txt | doc-to-email
6 lines. Reusable. Provider-agnostic. Shareable.

What This Means

CmdForge is NOT:

  • ✗ A package manager (like npm or pip)
  • ✗ A framework to learn
  • ✗ Just AI code generation
  • ✗ A replacement for shell scripting

CmdForge IS:

  • ✓ A capability registry
  • ✓ A tool composition engine
  • ✓ An AI-assisted discovery layer
  • ✓ A shared execution ecosystem

Ready to Try It?

Start building composable tools in minutes.

Get Started Browse Tools