Building a Private AI Coding Agent: Why I Switched from ChatGPT to Ornith

For a long time, my daily developer routine revolved around ChatGPT and Claude. And honestly, they are fantastic tools. But over time, the cracks started to show. I found my proprietary source code fly off into third-party cloud servers. I grew tired of the subtle lag during peak internet hours. And let's be honest, I grew tired of the ongoing monthly subscription bills just to keep an AI coding copilot active in my editor.

Then everything changed when I came across Ornith.

This guide walks you through what Ornith actually is, how it convinced me to leave cloud models behind. This will also give you a clear, step-by-step walkthrough for running it locally on a Mac using VS Code and Ollama.

Let's get started. 🚀

What is Ornith?

Ornith is an open-weights, highly specialized AI coding model built to deliver cloud-level agentic performance — but entirely offline. Once I switched my workflow to a local setup on my Mac, the difference was night and day: complete data privacy, snappy zero-latency responses, and a development assistant that costs me nothing.

Unlike general-purpose models built to summarize essays or write poetry, Ornith's neural network architecture is optimized exclusively for code syntax and workspace understanding.

Think of it as the difference between:

• A generic LLM: Someone who can recite facts but doesn't know your project.
• Ornith: A research assistant who lives in your environment, knows your code, remembers your goals, and acts on your behalf.

It is released primarily in two sizes:

• Ornith 9B (9 Billion parameters): A highly optimized model built to provide blazing-fast performance on consumer hardware like standard Apple Silicon Macs.
• Ornith 35B (35 Billion parameters): A powerhouse model meant for heavy multi-file architecture changes on high-end workstations.

How Ornith Differs from Existing LLMs

Here's where Ornith really starts to stand out:

• Built for Action, Not Just Autocomplete: It's a research assistant, not a search engine. It's genuinely good at understanding complex, multi-step instructions, untangling tricky structural bugs, planning out code changes across multiple files, and then executing them thoughtfully and methodically.

• Smarter Context Handling: Ornith uses an advanced attention mechanism that lets it read through dense, sprawling codebases without choking on memory (or VRAM). Instead of stumbling over big files, it actually handles them gracefully.

• Efficient Without the Trade-offs: The model is optimized so it barely loses any accuracy when compressed into smaller local formats like GGUF or MLX. In plain terms? A local Mac can run a 9B model that behaves like something far bigger running in the cloud.

• Optimized for Local Systems: Ornith is designed to run comfortably on a single GPU, or even just one CPU core. That makes it a perfect fit for local setups — no heavy cloud dependencies, no waiting, no compromises.

Put simply: while most models are built to respond, Ornith is built to do.

Ornith's Unique Selling Points (USPs)

If you are looking for a game-changing local companion, these are the core USPs that make Ornith stand out:

1. The "Internet Dependency" Bottleneck: Developers working on planes, trains, or in high-security, firewalled enterprise environments can now access a premium coding assistant completely offline.

2. Zero-Latency Privacy: Because it runs 100% locally on your machine, your company’s proprietary source code never leaves your laptop. No API keys, no cloud data logging, and no data leaks.

3. Cloud-Class Capability Offline: It bridges the performance gap. Ornith 9B punches far above its weight class, delivering logic reasoning and code generation quality that rivals significantly larger, expensive commercial models.

4. Transparent & Verifiable Every action is logged, every source is cited, and every claim can be traced. No black-box hallucinations — just auditable, reliable output.

5. The High Cost of API Subscriptions: Team subscriptions to cloud AI tools scale expensively. Running Ornith via Ollama costs $0/month.

6. Autocomplete vs. Logic Splitting: Most local setups force you to choose between a tiny model that can't write complex scripts, or a massive model that lags your computer when typing. Ornith's architecture, paired with modern extensions, solves this by handling heavy lifting seamlessly.

System Requirements

Before installing, ensure your Mac meets these requirements:

Compelte technical setup on macOS

This step-by-step blueprint walks you through setting up Ornith on your Mac, working around context-size limits, and wiring up a dual-model hybrid setup to keep your typing totally lag-free.

Step 1: Install Ollama and the Core Models

First things first — let's get the local engine installed. This is the little program that'll actually run your models right on your Mac's graphics chip.

1. Head over to Ollama's Official Website, download the macOS app, and give it a run.
2. Once that's installed, open your Mac's Terminal app and run these commands to pull the core models:

Copy
1# Download the main Ornith 9B engine for heavy reasoning and coding tasks
2ollama run ornith-1.5:9b
3
4# Download a lightning-fast helper model to handle background autocomplete
5ollama run qwen2.5-coder:1.5b-base
6
7# Download the embedding model so the AI can index and read your entire project
8ollama pull nomic-embed-text:latest

(Give it a few minutes — the first download can take a bit, and it'll speed up after that.)

Step 2: Configure a High-Context Virtual Model

Here's a little gotcha worth knowing: by default, local engines cap text memory at 8,192 tokens. And when you're dealing with large source code files, that limit can get hit fast — some files easily balloon past 13,000+ tokens.

To fix that, we'll build a custom profile that stretches Ornith's memory up to a nice, stable 12,288 tokens.

1. In your Terminal, create a new configuration file:

   Copy
   1nano Modelfile

2. Paste in these lines:

   Copy
   1FROM ornith-1.5:9b
   2PARAMETER num_ctx 12288

3. Save and close the file (Ctrl + O, then Enter, then Ctrl + X).
4. Tell Ollama to build your higher-capacity model:

   Copy
   1ollama create ornith-big -f ./Modelfile

Step 3: Connect to VS Code via Continue

To get a proper IDE sidebar chat and smooth inline code generation, we'll use the open-source Continue extension.

1. Open VS Code, head over to the Extensions tab (Cmd + Shift + X), search for Continue, and install it.
2. Once installed, click the new Continue icon in the left sidebar, then tap the Configs button in the left sidebar.
3. Replace the entire contents of the configuration file with this carefully tuned, speed-balanced setup:

Copy
1name: Main Config
2version: 1.0.0
3schema: v1
4models:
5  - name: Ornith 9B
6    provider: ollama
7    model: ornith-1.5:9b
8    contextLength: 163840
9    roles:
10      - chat
11      - edit
12      - apply
13  - name: Nomic Embed
14    provider: ollama
15    model: nomic-embed-text:latest
16    roles:
17      - embed
18  - name: Qwen2.5-Coder 1.5B
19    provider: ollama
20    model: qwen2.5-coder:1.5b-base
21    roles:
22      - autocomplete
23  - name: Nomic Embed
24    provider: ollama
25    model: nomic-embed-text:latest
26    roles:
27      - embed

Step 4: How to Use the Setup in Your Workflow

Now that your local pipeline is all set up and running, you've got three powerful ways to interact with it. Here's how each one works:

• Inline Code Generation (Cmd + I): Just highlight a blank spot (or an existing block) of code, smack that shortcut, and type what you need. The high-context Ornith model will then write the code right into your file for you.

• Keystroke Autocomplete: As you type away normally, the ultra-lightweight Qwen-Coder model quietly predicts the next bits and shows them as gentle grey "ghost text." Best part? It does all this without slowing down your typing at all — no lag, no interruptions.

• Full Workspace Context (@codebase): Head over to the Continue sidebar chat, and type @codebase right before your question. The embedding helper model will then scan through your entire directory, so Ornith can tackle big architectural questions like: "Where is user authentication handled?" — and actually give you a well-informed answer.

Together, these three methods let you work seamlessly — whether you're writing new code, finishing a line as you type, or diving into questions that span your whole project.

Step 5: Try Your First Command

Open the Continuous panel and try:

Copy
1"Refactor the auth module to use JWT"

Ornith will:

1. Analyze your auth code
2. Propose changes with a diff
3. Ask for confirmation before applying
4. Show you the results

🚀 Next Steps

Tips for Best Performance

• Limit context scope: Restrict Ornith to active projects to reduce latency.
• Enable caching: Turn on memory to avoid re-explaining context.
• Use local model for sensitive code: Keep proprietary code off external models.
• Batch research tasks: Queue multiple searches for deeper analysis.

Troubleshooting Common Local Setup Issues

Running large models on consumer hardware can sometimes run into integration quirks. Here is how to fix the most common errors:

Error: Request exceeds the available context size

• The Cause: You tried to pass a massive code file (e.g., 13,000+ tokens) to the model, exceeding Ollama's default 8,192 token internal ceiling.
• The Fix: Follow Step 2 of the installation guide above to create a custom Modelfile with the PARAMETER num_ctx 12288 setting, and map your config.yaml to target the custom ornith-big model container.

Issue: The Red Cross Icon appears and generation completely halts (with no error)

• The Cause: This indicates a connection loss between VS Code and Ollama, or a silent engine-level crash. Bumping context lengths too high (like 16k+ or 32k+) can instantly overwhelm your Mac's unified graphics memory (VRAM), causing the background Ollama daemon to terminate silently.
• The Fix:
  1. Verify Ollama is still running by checking your Mac's top menu bar or visiting http://localhost:11434.
  2. Drop the contextLength in your config.yaml down to a more stable value like 12288.
  3. Force-restart your editor extensions by opening the VS Code Command Palette (Cmd + Shift + P) and selecting Developer: Reload Window.

Error: create_new_file failed with message: contents argument is required

• The Cause: A communication bug between the Continue extension and the local model's automated file-creation tool wrapper. The model attempts to create a file but fails to properly package the text code payload into the script tool, sending an empty instruction that crashes the plugin.
• The Fix: Bypass the automated tool framework completely using one of two manual approaches:

Getting the Most Out of Ornith

Daily workflows that supercharge productivity:

1. Deep Research: "Summarize the latest papers on LLM agent memory"
2. Code Reviews: "Review my PR and suggest improvements"
3. Debugging: "This test keeps failing — find the root cause"
4. Documentation: "Generate docs for my API endpoints"
5. Task Automation: "Set up CI/CD for this project"

Conclusion

Ornith represents a paradigm shift in how developers and researchers interact with AI. By combining agentic tool use, deep research, and persistent memory with native VS Code integration, it solves the real problems that generic chatbots can't touch.

Whether you're on a Mac or coding in VS Code, Ornith transforms your environment into an intelligent, context-aware workspace.

Happy researching and coding! 🐦

For updates, visit the official Ornith website and community forum.

Cover photo by Om Kamath on Unsplash.