Prompt Engineer's Guide: Zyphra, Cohere & Poolside – New Open Models Tested

Three new open models dropped in quick succession, and the question isn't whether they're impressive. It's whether they're worth your time to set up, and what you actually need to change about your prompts to get good results from each one. That's what this guide answers.

Zyphra, Cohere Command, and Poolside each have a distinct design philosophy, and that philosophy shows up directly in how they respond to prompts. Generic advice won't help you here. What will help: a quick model-by-model breakdown, copy-ready prompt templates for three real tasks, a local deployment checklist, and an honest head-to-head comparison so you know which model earns a spot in your workflow.

Quick Model Overview: What Each One Is Actually Good At

Before you write a single prompt, you need to know what each model is optimized for. Prompting against the grain of a model's design is one of the fastest ways to get mediocre output.

Zyphra: Speed First

Zyphra is oriented toward fast text generation. Its context window is on the shorter end. That constraint matters: it's not the right tool for long-document summarization or multi-step reasoning chains. But for rapid prototyping, brainstorming, and quick content generation, it returns results fast and costs less to run, locally or via API.

Cohere Command: Structure and Control

Cohere Command tends to excel at instruction following and structured output. Its context window is notably larger than Zyphra's, which makes it suited for document-heavy tasks: report generation, data extraction, anything where you need the model to hold a lot of context and produce output in a predictable format. It responds well to explicit schema instructions, including JSON.

Poolside: Balanced and Conversational

Poolside sits between the two. It leans conversational, handles a reasonable range of tasks without heavy prompt engineering overhead, and performs consistently when you keep your prompts concise. Context length varies depending on the quantization level you're running.

The short version: Zyphra for speed, Cohere Command for control, Poolside for general-purpose tasks where you don't want to over-engineer.

Ready-to-Use Prompt Templates for Each Model

These templates cover three tasks most prompt engineers run into constantly: blog post outlining, customer support email drafting, and code explanation. Each prompt is written to fit the model's strengths. Copy them directly, swap in your content, and adjust from there.

Task 1: Blog Post Outline Generation

Zyphra — Keep it clear and brief. The model doesn't need elaborate instruction scaffolding for simple generation tasks.

Create a brief outline for a blog post on "The Benefits of Meditation."
Include 3 main sections with bullet points.

Cohere Command — Ask for structure explicitly. This model is built to follow schema instructions, so give it one.

Generate a structured JSON object containing the outline for a blog post
titled "The Benefits of Meditation."

The object should have the following keys:
- "title": the full post title
- "sections": an array of section titles
- "points": an array of bullet points per section

Return valid JSON only. No additional commentary.

Poolside — Short, direct, format specified. Poolside performs well when you don't over-instruct.

Outline a blog post on "The Benefits of Meditation."
Use numbered sections. Be concise.

Task 2: Customer Support Email Response

Zyphra

Write a short, friendly email responding to a customer complaint
about a delayed order. Apologize sincerely and offer a 10% discount
on their next purchase. Keep it under 100 words.

Cohere Command

Generate a JSON object representing an email response to the following
customer inquiry:

[INSERT CUSTOMER MESSAGE HERE]

The object should include these keys:
- "subject": email subject line
- "greeting": opening line
- "body": main response (empathetic, focused on resolution)
- "closing": sign-off

Return valid JSON only.

Poolside

Respond to this customer message in a professional, helpful tone:

[INSERT CUSTOMER MESSAGE HERE]

Offer an apology and a concrete solution. Keep the response under 100 words.

Task 3: Code Explanation

Zyphra

Explain the following Python code snippet in simple terms:

[INSERT CODE HERE]

Cohere Command

Provide a detailed explanation of the following code block.
Cover: its purpose, key variables, and two potential use cases.
Format your response as markdown with headings and bullet points.

[INSERT CODE HERE]

Poolside

What does this code do? Explain it like I'm new to programming.

[INSERT CODE HERE]

Before (generic): "Write a story about a robot."

After (Zyphra-tuned): "Generate a concise, imaginative story (~100 words) featuring a friendly robot exploring a futuristic city. Focus on vivid descriptions and playful interactions."

The second prompt gets you something usable in one pass. The first requires two or three rounds of correction. Specificity is cheaper than iteration.

One consistent pattern across all three models: structured prompting is essential for Cohere Command, brevity helps Poolside, and Zyphra responds well to clear, plain-English requests. Don't try to force a model into a style it doesn't naturally prefer. You'll spend more time fighting the output than editing it.

If you want pre-built templates across personal and business use cases, Ultra Prompt's structured template library is a fast way to skip the "write prompt from scratch" step and get straight to testing.

Lightweight Deployment Playbook: Running These Models Locally

API access is fine for testing. But if you're running these models repeatedly, local deployment eliminates per-token costs and keeps your data off third-party servers. The tooling to do this is genuinely accessible now. You don't need a data center.

If you're newer to local model setup, the post Running Your Own AI at Home covers the foundation before you tackle model-specific configuration.

What You Need

• A mid-range GPU-enabled laptop. More VRAM gives you headroom for larger context windows and less quantization compression, so it's worth checking the model's recommended specs before you pull it locally.
• Ollama or LM Studio. Both handle model download, quantization, and local serving. Check each tool's documentation for platform support and interface style before picking one.

Setup in Three Steps

Step 1: Install Ollama or LM Studio. Both have local inference setups that work on consumer hardware.

Step 2: Pull the model you want to test. In Ollama:

ollama pull zyphra

Step 3: Run it directly from the command line:

ollama run zyphra "Write a haiku about cats."

Or load it in LM Studio's interface and paste prompts from the template section above.

Edge Deployment: Possible, With Trade-offs

Running on low-power edge devices is possible for offline, non-interactive use cases where speed isn't critical. Think: local-first tools that run occasional inference rather than interactive back-and-forth. Don't expect the same throughput you'd get on a dedicated GPU. For latency-sensitive applications, a laptop GPU is a better fit.

For a deeper comparison of when local wins versus cloud, Local AI vs Cloud AI: What Each Wins, and Where to Run What lays out the trade-offs in full.

Once you have a model running locally, Ultra Prompt's templates copy directly into your CLI or LM Studio prompt field. The template library is organized by use case, so you're not hunting for a starting point every time you switch tasks.

Head-to-Head Evaluation: Same Prompts, Three Models

Here's what the evaluation framework looks like when you run all three models on the same tasks. Rather than placeholder scores, use this structure as your own testing rubric. The criteria that matter are consistent across any model comparison:

• Output quality: Is the response coherent, relevant, and on-topic?
• Instruction adherence: Did the model follow the format you specified?
• Speed: Time to first token and full response, run locally.

The pattern that emerges: Cohere Command wins on tasks where format and completeness matter most. Zyphra wins when you need fast first drafts you'll edit yourself. Poolside is the reliable middle option for tasks where you don't want to over-specify the prompt.

The practical rule: Start with Zyphra when you're iterating fast and don't need a specific output format. Move to Cohere Command when the output needs to be machine-readable or structurally precise. Use Poolside when you want something usable with minimal prompt engineering overhead.

For more on keeping your judgment in the loop as you test models against each other, the post Trusting AI Without Losing Your Own Judgment is worth reading alongside this one.

How to Evaluate Any New Open Model on Your Specific Tasks

New models will keep shipping. The three-step evaluation process that works across all of them:

1. Pick 3 tasks you run regularly. Use real prompts from your actual workflow, not benchmarks designed to flatter.
2. Run identical prompts across all candidates. Don't adjust mid-test. You're evaluating the model, not your prompting skill at that moment.
3. Score on three dimensions: output quality for your use case, instruction adherence, and local speed on your hardware. Weight them based on what actually matters to your workflow.

That evaluation process takes roughly 30 minutes per model. It's more useful than any benchmark table, because benchmarks aren't your tasks.

FAQ

How do Zyphra, Cohere, and Poolside compare for prompt engineering tasks?

Zyphra is oriented toward speed and works best on short-form generation where you need fast iteration. Cohere Command is the strongest option for structured output, JSON schemas, and tasks requiring precise instruction following. Poolside handles general-purpose tasks well and requires less prompt engineering overhead than the other two.

What are the best prompt templates for the latest open models?

For Zyphra: short, plain-English prompts with clear output constraints (length, tone, format). For Cohere Command: explicit schema instructions, JSON keys specified upfront, "return valid JSON only" at the end. For Poolside: concise prompts with a stated format preference. Ultra Prompt's structured template library has tested starting points across both personal and business use cases.

Can I run these models locally on a laptop or edge device?

Yes. Ollama and LM Studio both make local installation accessible on a GPU-enabled laptop. A mid-range GPU handles quantized versions of these models at usable inference speeds. Check each model's recommended specs for guidance. Edge deployment on low-power devices is possible but significantly slower, and is best suited for offline, non-interactive use cases.

What are the cost and performance trade-offs of running these models locally vs. via API?

Local deployment has a hardware cost upfront but eliminates per-token API fees over time. It also keeps your data off third-party servers. The trade-off is setup complexity and the fact that your local throughput depends on your hardware. For high-volume, repetitive tasks, local usually wins on cost. For occasional use, API access may be simpler to manage.

Do these models respond well to chain-of-thought prompting?

Cohere Command handles multi-step reasoning instructions reliably, given its larger context window and instruction-tuning. Zyphra is less suited for long chain-of-thought sequences given its shorter context limit. Poolside performs reasonably on short reasoning chains. For complex, multi-step tasks, Cohere Command is the stronger choice.

Three models, three distinct strengths, and you don't have to pick one forever. Run them against your actual tasks, score what matters to you, and let the results decide. The prompt templates above give you a consistent baseline to start from.

If you'd rather skip the setup work and get directly to testing, Ultra Prompt's structured template library gives you a ready-made starting point for whatever these models, or the next batch, get thrown at.