Introducing LessPrompt: Because Running Out of Tokens Shouldn't Feel Like Running Out of Gas

I know yet another AI post. We're all swimming in them. But this one comes from a very specific pain point I keep running into when building real systems: the strange, new anxiety of running out of tokens.

Over the past year, many of us have developed a quiet fear that writing one more descriptive sentence might push the prompt over the edge — like watching your car's fuel gauge drift toward empty on a long highway. Token usage has become the new MPG, and it's not always clear when you're burning premium.

So I've been experimenting with a new side project to fix this: LessPrompt. It's a prompt pre-processor that rewrites prompts to be clearer, smaller, more structured, and more deterministic — without changing their intent.

Think of it as fuel efficiency for your prompts. Same destination, fewer tokens.

---

Why Now?

As agentic systems get more sophisticated, the number of prompts being generated (and re-generated, mutated, templated, and expanded) has exploded. The more complex the workflow, the more verbose the prompts become — and the more unnecessary tokens get burned along the way.

Humans write long prompts. Agents write even longer ones. And LLMs love to add more text than anyone asked for.

But the twist: You can often get the same output with half the tokens simply by restructuring and tightening the language.

If we optimize everything else in software, why not optimize prompts too?

---

Early POC: Two Complementary Approaches

I've been developing two approaches simultaneously, and the early results are promising.

1. Rules-Based Prompt Optimization

A deterministic pipeline that:

• Removes noise (greetings, filler language)
• Extracts structure (Goal → Context → Input → Constraints → Output Format)
• Normalizes phrasing into lean, canonical patterns
• Eliminates redundant or contradictory directives

This alone reduces token count 20–40% while increasing clarity.

2. Lightweight LLM Refinement (CPU-friendly micro-models)

Sometimes rules can only take you so far. For semantic compression and light paraphrasing, I've been using tiny LLMs running:

• Quantized
• On local CPU
• At extremely low cost

Their role isn't to solve the user's task — just to shorten and clarify the prompt while preserving meaning. A small “semantic compressor” layer.

Surprisingly, for many domains (including healthcare), these lightweight models work extremely well.

---

What This Enables

LessPrompt becomes a small but powerful layer for:

• Agent-based systems
• LLM ops pipelines
• Clinical reasoning apps
• Prompt-heavy backend automations
• FHIR- and CQL-driven workflows
• Knowledge authoring tools
• High-volume generative pipelines

Anywhere prompts are created dynamically, LessPrompt can lower costs, improve reliability, and reduce unnecessary token churn.

And no, you don't need a GPU farm.

---

The Vision

Long-term, the project could evolve into:

• A drop-in MCP service for agentic workflows
• An HTTP API for apps and backend services
• A lightweight desktop utility
• Domain-specific profiles (e.g., healthcare, analytics, legal)
• A “prompt linter” that warns you before you waste tokens
• A compiler-like DSL for structured prompt creation

Even the early results show that you can materially reduce tokens and improve prompt quality without large, expensive models.

---

More to Come

I'll continue iterating on LessPrompt, and we'll be experimenting with these ideas inside ReasonHub as well — especially around clinical reasoning workflows, terminology operations, and high-volume agentic processes. It turns out that efficient prompting isn't just an academic exercise; it directly affects cost, reliability, and composability in real deployments.

More experiments, demos, and data soon — and if you're working on similar challenges or want to test this in your workflows, I'd love to chat.