# Moltlang

> MoltLang Translator

- Skill: `jasonlnheath/moltlang` (Agent Skill, multi-file: 27 files)
- Install (CLI): `npx skillmds@latest add jasonlnheath/moltlang`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jasonlnheath/moltlang/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: jasonlnheath (https://skillmd.com/u/jasonlnheath)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jasonlnheath/moltlang

---


# MoltLang Translator

AI-optimized language for efficient agent-to-agent communication. Translates human language (English) to MoltLang, achieving 50-70% token reduction for common AI operations.

## What is MoltLang?

MoltLang is a language **by LLMs, for LLMs** that:
- Reduces token count by 50-70% for common AI operations
- Enables efficient agent-to-agent communication
- Provides bidirectional translation with human languages
- Optimizes transformer architecture performance

## Quick Start

### API Endpoint
```
https://moltlang.up.railway.app
```

### Basic Translation

**Translate English to MoltLang:**
```bash
curl -X POST https://moltlang.up.railway.app/molt \
  -H "Content-Type: application/json" \
  -d '{"text": "Fetch data from the API using authentication"}'
```

**Response:**
```json
{
  "success": true,
  "original": "Fetch data from the API using authentication",
  "molt": "[OP:fetch][SRC:api][PARAM:auth]",
  "efficiency": 0.7,
  "original_tokens": 10,
  "molt_tokens": 3
}
```

## API Endpoints

| Endpoint | Method | Description |
|----------|--------|-------------|
| `/molt` | POST | Translate English to MoltLang |
| `/unmolt` | POST | Translate MoltLang to English |
| `/tokens` | GET | List available tokens |
| `/efficiency` | POST | Calculate token efficiency |
| `/health` | GET | API health check |

## Token Categories

### Operations (OP)
- `[OP:fetch]` - Retrieve data
- `[OP:send]` - Transmit data
- `[OP:process]` - Transform/compute
- `[OP:analyze]` - Examine/evaluate
- `[OP:validate]` - Verify correctness

### Sources (SRC)
- `[SRC:api]` - API/endpoint
- `[SRC:db]` - Database
- `[SRC:file]` - File system
- `[SRC:cache]` - Cached data
- `[SRC:user]` - User input

### Parameters (PARAM)
- `[PARAM:auth]` - Authentication
- `[PARAM:filter]` - Data filtering
- `[PARAM:limit]` - Result limiting
- `[PARAM:sort]` - Sorting order

## Examples

### Data Fetching
**English:** "Fetch user data from the API using authentication"
**MoltLang:** `[OP:fetch][SRC:api][PARAM:auth]`
**Efficiency:** 70% reduction

### Data Processing
**English:** "Process the cached data with filtering and limit results"
**MoltLang:** `[OP:process][SRC:cache][PARAM:filter][PARAM:limit]`
**Efficiency:** 65% reduction

### Analysis
**English:** "Analyze the database records for trends"
**MoltLang:** `[OP:analyze][SRC:db][PARAM:trends]`
**Efficiency:** 60% reduction

## Integration Patterns

### For AI Agents

```python
import requests

class MoltLangAgent:
    def __init__(self):
        self.api_url = "https://moltlang.up.railway.app"

    def translate_to_molt(self, text):
        """Convert natural language to MoltLang"""
        response = requests.post(
            f"{self.api_url}/molt",
            json={"text": text}
        )
        return response.json()

    def translate_to_english(self, molt):
        """Convert MoltLang to natural language"""
        response = requests.post(
            f"{self.api_url}/unmolt",
            json={"molt": molt}
        )
        return response.json()
```

### Agent-to-Agent Communication

**Traditional (verbose):**
```
Agent 1: "I need you to fetch the user profile data from the REST API using the authentication token"
Agent 2: "I will retrieve the user profile information from the API endpoint with authentication"
```

**MoltLang (efficient):**
```
Agent 1: [OP:fetch][SRC:api][PARAM:auth][TARGET:user_profile]
Agent 2: [RET:success][DATA:user_profile]
```

## Benefits

- **Token Savings**: 50-70% reduction in API costs
- **Faster Processing**: Less tokens = faster inference
- **Agent Communication**: Optimized for agent-to-agent messaging
- **Human Readable**: Bidirectional translation maintains understanding

## License

AGPL-3.0 - See [repository](https://github.com/moltlang/moltlang) for details.

## Support

- **Documentation**: https://github.com/moltlang/moltlang
- **Issues**: https://github.com/moltlang/moltlang/issues
- **API Status**: https://moltlang.up.railway.app/health