Use Cases & Workflows

Build AI agents and tool-using LLM apps first—with Neo in VS Code planning, executing, and iterating on real code. Classical ML and training pipelines are here too, as a focused track when your problem needs datasets and models—not prompts alone.

Neo reads your repository, runs steps locally (or on cloud you configure), and leaves inspectable artifacts: code, configs, evals, and traces. Additional example walkthroughs live under Projects in the documentation sidebar.

Why agent builders start with Neo

Goals grounded in your repo

Plans reference real files, APIs, and constraints—not a blank chat. Neo decomposes work into steps you can review and rerun.

Tools, MCP, and glue code

Wire HTTP APIs, MCP servers, scripts, and CLIs into a coherent agent or service—see MCP Optimization and Repo Query Agent.

Multi-agent orchestration

Split planner, coder, and reviewer roles; ship from specs to diffs—Spec to Ship, LLM Council, Agent swarms.

Evals, safety, and ops

Benchmark hallucinations, harden prompts, watch traces—Hallucination Benchmark, Prompt injection defense, Observability.

The agent loop on Neo

Neo fits how teams describe modern agent work:

GoalPlanTools & code executionEvaluation & guardrailsArtifacts in Git

You stay in control: approve risky steps, edit generated code, and version prompts next to application code. For more examples by theme, use the Projects section in the sidebar.

Deep dive: agents built with Neo

Three end-to-end patterns illustrated with linked walkthroughs—swap in your domain and repo.

Spec to multi-agent delivery

From product spec to merged code

Multi-agent

Open project

What you ask Neo

Turn this spec into a plan, implement in-repo, and have a reviewer agent validate against acceptance criteria.

How it comes together

1Parse spec: requirements, risks, acceptance tests

2Planner agent: milestones and file-level tasks

3Implementer + reviewer agents with optional human gates

4Traceability from spec lines to diffs and tests

What you get

Task breakdown and dependency graph

PR-ready changes with review notes

Checks tied to acceptance criteria

Audit trail for compliance-minded teams

Repository intelligence at scale

Ask questions across any large codebase

Tools & retrieval

Open project

What you ask Neo

Clone this repo, map architecture, then answer multi-turn questions without reading every file by hand.

How it comes together

1Ingest tree; skip noise (binaries, vendored deps)

2Map-reduce: parallel chunk analysis, hierarchical merge

3Streaming chat (e.g. SSE) with grounded answers

4Iterative refinement as questions get specific

What you get

Architecture summary and dependency view

Conversational interface over the merged context

Predictable token bounds per stage

Reusable ingestion pattern for internal monorepos

RAG and document-grounded apps

Retrieval you can ship

RAG & multimodal

Open project

What you ask Neo

Build a RAG stack over our documents (and modalities we care about), with evaluation hooks and clean APIs.

How it comes together

1Ingestion: PDFs, OCR pipelines, or structured stores

2Chunking, embeddings, and retrieval strategy

3Grounded generation with citation-style grounding

4Eval loops: quality, drift, and regression tests

What you get

Index and metadata contracts

API or worker you can deploy

Eval reports and failure buckets

Pairs well with Invoice OCR and domain RAG variants

More agent & tool patterns

Pick a theme in the tabs below, then use the link rows—each opens the full walkthrough (same pages as under Projects in the sidebar).

Multi-agent & researchSwarms, research, docs-from-codeMCP, CI/CD & codeTooling, pipelines, refactorsVoice & realtimeStreaming speech, low-latency UXMemory, evals & safetyObservability, benchmarks, hardening

Stock Trading Agent SwarmCoordinated agents for strategy-style workflows Hypothesis EngineStructured autonomous research AutoDocKeep documentation aligned with code

MCP Optimization AgentImprove MCP servers and call patterns Helix CI/CDSelf-healing pipeline runs Code Analysis & RefactoringGuided reviews and safe edits

CPU TTS + streaming LLMVoice loop without a GPU requirement Speech-to-speech translationRealtime multilingual audio

Multi-agent memoryDurable context across turns Observability platformTraces and fleet-level signals LLM EvaluatorSystematic scoring rubrics Hallucination benchmarkCompare models on fabricated answers Prompt injection defensePolicy and filter patterns Consistency monitorCatch brittle prompts early

Neo in VS Code

Neo runs in your editor: it reads your repo, runs tasks, and leaves diffs and logs you can inspect. Watch the demos first, then try the example prompts—larger reference builds are linked where they help.

Debugging & error resolution

Neo traces stack frames and code paths to suggest targeted fixes when an agent or service misbehaves.

“Why is the session token null after the third redirect in auth_middleware.py?”

Reference: Code Analysis & Refactoring Agent

Install / open Neo in VS Code

Local data analysis

EDA on CSV and tabular files stays on your machine—good before you lock in a pipeline or feature store.

“Summarize nulls and outliers in sales_data.csv”Try this in VS Code

Repos & open source

Map issues to files, suggest patches, and onboard faster—the same muscle as large-repo agents.

“What needs to change to close GitHub issue #402?”

Reference: GitHub Repo Query Agent

Open in VS Code

ML & model development

When the job is data and metrics first—not only prompts—Neo still runs end-to-end ML work: tabular, time series, speech, vision, and training pipelines. Everything stays inspectable in your repo, the same way as agent tasks.

Typical pipelineData Ingestion → Validation → Feature Engineering → Model Training → Evaluation → Deployment

Runs locally in VS Code by default; use cloud resources only when you configure them. Agent features and ML often ship together—e.g. fine-tuned ASR behind a voice agent.

Walkthroughs

Each tile is a full write-up—title on the first line, what you get on the second.

Fine-tune an LLM with NeoAdapters, data prep, and evaluation in-repo Multilingual ASR (Qwen)Speech recognition pipeline you can ship Carbon-aware trainingSchedule jobs with emissions in mind Quantization-aware trainingEdge deployment without guesswork Time series forecastingNatural language → TimesFM-style workflows

Starter scenarios (order-of-magnitude)

Scenario	Type	Typical data	Ballpark time
ETA prediction	Tabular / time series	CSV, Parquet	Tens of minutes
Fine-tune Whisper	Speech	Audio + transcripts	Hours
Sleep stage classification	Biomedical TS	Wearables, EEG	~30–60 min
Network anomaly detection	Security	Multi-source logs	Tens of minutes
Churn modeling	Tabular	CRM / transactions	Tens of minutes

Times depend on data size and hardware. Describe the dataset and target metrics in your task — Neo will align artifacts and reports the same way as for agents.