CommandCode AI: Improving Open Model Tool-Calling with the Taste Framework

Solving Tool Confusion in Open Models

Open-source LLMs often suffer from "tool confusion," where they fail to adhere to strict tool-calling schemas despite being highly capable. Ahmad Awais, CEO of CommandCode AI, discovered that many perceived weaknesses in open models are not capability gaps but rather "harness/contract issues"—failures in how the model interacts with the tool-calling framework.

In internal evaluations, implementing a deterministic repair layer allowed DeepSeek V4 Pro to outperform Opus 4.7 in 6 out of 10 cases. The core issue is that open models may repeatedly send incorrect schemas (e.g., sending a null object where an array is expected) and ignore standard error messages (like Zod validation errors), entering a loop of failure.

The "Validate-then-Repair" Approach

Instead of simply returning an error to the LLM when a tool call fails, CommandCode AI implements a repair layer that fixes the input deterministically before the tool is executed.

• Deterministic Fixes: If a model consistently emits a JSON string instead of an array, the repair layer converts it to an array automatically.
• Repair Hints: After repairing the input and returning the tool's result, the system sends a "repair hint" back to the model. This teaches the model the correct format for future calls.
• Judgment Calls: For missing parameters (e.g., a file offset for reading a file), the system makes a reasonable default assumption (e.g., reading the first 100 lines) to keep the agent moving forward.

Awais notes that once a model receives a successful result via a repair, it often corrects its behavior in subsequent calls, becoming significantly more creative and effective.

Fixing "Design Slop" with Compositional Frameworks

Beyond tool calling, the same logic of deterministic repair and structured guidance is applied to "design slop"—the generic, often repetitive aesthetic patterns (like the ubiquitous indigo-purple gradients) produced by LLMs.

Reducing Design Slop

CommandCode AI reduces design slop by providing models with a compositional framework and specific constraints:

• Intent-First Design: Forcing the model to define the intention behind a design (e.g., identifying a dashboard as a "monitor surface") before implementing it.
• OKLCH Color Space: Forcing models to use OKLCH instead of HSL or RGB. LLMs demonstrate better control over lightness and perceived color consistency when using OKLCH, which aligns more closely with human vision.
• Design Smells and Patterns: Implementing a set of "design smells" (things to avoid) and seven core design patterns derived from professional designers.

By treating design as a set of deterministically fixable patterns rather than a vague aesthetic request, the system can eliminate the majority of AI-generated design artifacts.

The Taste Framework: Meta-Neurosymbolic Memory

CommandCode AI utilizes a framework called "Taste" to manage developer preferences and skills. Taste is described as a meta-neurosymbolic architecture that learns a developer's specific coding style and preferences over time.

Skills vs. Taste

• Skills: Specific, documented rules or patterns (e.g., "prefer pnpm for installing packages").
• Taste: The higher-order engine that automatically identifies repeated preferences across a repository and generates skill files.

Key Characteristics of Taste

• Automatic Learning: Taste observes developer edits and accepts/rejects to identify micro-decisions (e.g., a specific PR workflow) that the developer might not think to document manually.
• Transparency: Taste files are stored as Markdown in the Git repository, making them transparent and reviewable via Pull Requests.
• Portability: Taste files can be shared across projects. A developer can use a high-quality model (like Opus) to establish a project's "taste" and then use cheaper, open models to maintain the project while adhering to that established taste.

Future Roadmap and Open Source

CommandCode AI intends to open-source the CommandCode CLI to make it completely hackable. The goal is to create a system that supports the "best of the best" models (both open and closed) while allowing users to integrate their own local models. This approach aims to provide a highly curated experience similar to the Apple ecosystem, rather than a broad, unoptimized list of available models.