A veterinarian examines a horse showing signs of colic. She opens V.E.T.S. and speaks naturally to Florence, her AI medical assistant:

"Gelding, 12 years, acute abdominal pain, elevated heart rate, no gut sounds on right side."

That sentence enters the system as a Pr Prompt — the structured instruction that tells the AI what to do. The prompt carries context: who's asking, what animal, what urgency level.

The AI doesn't just read words. It converts them into mathematical meaning through Em Embeddings — turning "no gut sounds on right side" into a vector that's mathematically close to "right dorsal displacement" and "large colon impaction."

This understanding is powered by Lg Large Language Models that have been trained on vast medical and veterinary knowledge, then grounded in V.E.T.S. data so they understand your specific context.

Those vectors search the knowledge base through Vx Vector Search — comparing against indexed documents to find the most relevant protocols, case histories, and treatment guidelines.

Florence uses Fc Function Calling to pull the patient's history, check previous treatments, and look up herd-level patterns — structured actions the AI takes on your behalf.

The matching results are assembled through Rg RAG (Retrieval-Augmented Generation) — the pattern that grounds the AI's response in actual V.E.T.S. knowledge rather than generic training data.

Before the response reaches the vet, it passes through Gr Guardrails — checking medication dosages against species-specific limits, flagging drug interactions, ensuring the recommendation doesn't contradict established protocols.

Images and scans — X-rays, ultrasound findings, wound photos — are processed via Mm Multimodal understanding, where the AI interprets visual data alongside text.

Florence operates as an Ag Agent — not just answering a question but orchestrating a multi-step workflow: search, retrieve, check safety, format the response for a veterinarian in the field.

The system continuously improves through Ft Fine-tuning — learning from every correction, every expert edit, every new protocol added to the knowledge base.

All of this is built on proven Fw Frameworks for reliability — battle-tested patterns for prompt engineering, retrieval pipelines, and response generation that ensure consistent quality.

The AI is regularly stress-tested through Re Red-teaming — deliberately probing for weaknesses, hallucinations, and edge cases before they reach real users.

For routine tasks — form auto-fill, quick lookups, simple categorization — efficient Sm Small Models handle the work instantly, saving the heavy reasoning for cases that need it.

Complex cases engage Ma Multi-Agent collaboration — Florence consults Clerk for patient records, Penny for billing codes, and Lassie for herd-level context, all coordinated seamlessly.

Training data is enhanced with Sy Synthetic Data for rare conditions — generating realistic but artificial examples so the AI can learn about uncommon cases without waiting for them to happen.

The system is growing toward responsible Au Autonomy in routine decisions — auto-categorizing records, scheduling follow-ups, flagging anomalies — always with human oversight a click away.

In Interpretability ensures you can always see WHY the AI made a recommendation — which documents it referenced, what confidence it has, and where uncertainty exists.

And for the most complex diagnostic reasoning, advanced Th Thinking Models work through problems step by step — weighing differential diagnoses, considering contraindications, and explaining their reasoning chain.

Imagine two clinically identical colic cases hit Florence in the same week. Same model. Same minion. Same prompt template. The first vet gets a sharp, ranch-specific recommendation grounded in last month’s lab work for that herd. The second vet gets a generic textbook answer that could have come from any veterinary forum. Same function, different output. Why?

Because the answer was never determined by the model alone. It was determined by every token that landed in the context window before the model produced its first output token — the system instructions, the retrieved chunks, the tool returns, the conversation so far, the embedded image, the threshold check that fired or didn’t. The model is a function of its inputs. The output is a trajectory through the space of possible token sequences, and that trajectory is bent — measurably, controllably — by every input the system feeds it.

Vibe coding is what happens when you ignore this: type a prompt, hope for the best, blame the model when the answer is bad. Trajectory engineering is the opposite discipline. It treats every input as a steering surface. V.E.T.S. has six of those surfaces wired into the platform, and a seventh that ties them together. Here is each one.

1. Foundations — the model is a function of its inputs

The base case. A Pr Prompt is not a question — it is a structured instruction that carries role, task, constraints, and context. The same medical query expressed two different ways enters the model as two different vectors and produces two different trajectories.

That vectorization is not metaphor. Every input token is converted into mathematical meaning through Em Embeddings — positions in a high-dimensional space where semantically similar text clusters together. Trajectory engineering starts here: if you understand that “painful belly” and “acute abdominal distress” embed to different neighborhoods, you understand why word choice in the prompt is not stylistic — it is steering.

The generative function itself is the Lg Large Language Model. It maps the assembled input context to a probability distribution over the next token, samples, appends, and repeats. Everything else on this page is a strategy for what to put in front of that function so the sampled trajectory ends where the practitioner needs it to end.

2. Retrieval — the biggest lever is what you put next to the prompt

The prompt is the smallest input. The largest is everything you inject around it. Vx Vector Search selects which knowledge chunks join the prompt in the context window — the chunks that sit closest in embedding space to the user’s query. The selection is the steering. A retriever that pulls the right protocol bends the trajectory toward the right answer; a retriever that pulls a near-miss bends it toward a plausible-sounding wrong one.

Those retrieved chunks are injected into the prompt through the Rg RAG pattern — Retrieval-Augmented Generation. RAG is not a model. It is a discipline for shaping the input so the model’s trajectory is anchored to specific, verifiable knowledge rather than the diffuse statistical average of its training data. In V.E.T.S., RAG is what makes Florence answer about this ranch’s herd rather than about cattle in general.

For the data that must be exact — a vaccination date, a current weight, a drug last administered — retrieval is the wrong tool. Fc Function Calling is the most reliable trajectory steering of all, because it is not probabilistic at all. The model emits a structured tool call, V.E.T.S. executes a stored procedure against the database, and the deterministic result re-enters the context as fresh tokens the model now treats as ground truth. Retrieval bends the trajectory; tool calls clamp it.

3. Modality — inputs are not just text

A wound photograph, an ultrasound still, a scanned vaccination card — each is an input that joins the context window alongside the prompt. Mm Multimodal inputs steer the trajectory in ways pure text cannot. The same prompt “is this healing normally?” produces wildly different trajectories depending on whether the model also sees the wound or has to imagine it. Trajectory engineering treats image inputs with the same intent as text inputs: chosen, framed, captioned.

4. Bounds — catching trajectories that drift

Even perfectly shaped inputs produce probabilistic outputs. Trajectory engineering installs bounds: Gr Guardrails are hard checks against the output before the practitioner ever sees it — dosage outside species limits, contraindicated drug combinations, retrieval confidence below threshold. A guardrail does not improve the trajectory; it refuses to ship a trajectory that landed in the wrong region.

Not every decision needs the heavy model. Sm Small Models are the cheap classifiers that filter, route, and pre-process inputs before the expensive trajectory begins — keyword scoring for minion handoffs, intent detection, fast similarity checks. This is trajectory engineering as economics: spend tokens on the trajectories that matter, not the ones a tiny model can settle in a millisecond.

All of the above runs on proven Fw Frameworks — the patterns and infrastructure that handle retries, structured output parsing, streaming, prompt assembly, and error propagation. Frameworks are not glamorous, but they are how a trajectory survives contact with production. A clever prompt that only works when the network is fast and the JSON is well-formed is not engineering.

5. Training-time engineering — bending the baseline

The previous beats shape inputs at query time. Trajectory engineering also operates at training time: adjust the function itself so its default trajectories are better. Ft Fine-tuning is the slow flywheel: every expert correction in V.E.T.S. becomes training signal, and the next generation of the model starts its trajectories from a slightly better baseline. The vet who corrects Florence today is shaping the trajectory of every query Florence handles next month.

Fine-tuning needs data. For rare conditions — the cases the field has not produced enough of to train on — Sy Synthetic Data fills the gap. Generated examples of uncommon presentations, edge-case workflows, adversarial inputs. The point is not to fake reality; it is to give the model trajectories to learn from before reality forces them.

6. Verification — probing trajectories before they ship, making them legible after

Before trusting a trajectory in production, attack it. Re Red-teaming deliberately probes for the inputs that produce the worst trajectories — prompt injections, hallucination triggers, contradictions across retrieved chunks, dosages right at the species boundary. Trajectory engineering is incomplete without a discipline for finding the trajectories you didn’t plan for.

Once a trajectory has shipped to the practitioner, it must be inspectable. In Interpretability means the vet can see why the answer says what it says: which chunks were retrieved, what their confidence scores were, what tool calls fired, where uncertainty remained. A trajectory you cannot inspect is a trajectory you cannot trust.

For the cases that resist one-shot answers — differential diagnoses, multi-step workups, contradictory evidence — the trajectory itself should be longer. Th Thinking Models are LLMs configured to generate explicit reasoning tokens before the final answer. Chain-of-thought is not a prompting trick — it is a longer, higher-resolution trajectory through the problem, and on hard problems it measurably outperforms the equivalent one-shot.

7. Ownership — who steers the trajectory end-to-end

Everything above is a steering surface. The question that remains is: who is steering? An Ag Agent is the entity that owns a trajectory from input to output — picks the prompt template, runs the retrieval, calls the tools, applies the guardrails, decides when the answer is done. In V.E.T.S., every minion is an agent. Every minion owns a class of trajectories.

Hard problems rarely fit one agent. Ma Multi-Agent systems coordinate multiple owned trajectories — a coordinator decomposes the request, specialists each run their own bounded trajectory, results are composed back. The discipline expands: you are no longer engineering one trajectory, you are engineering a graph of them, plus the handoffs between them.

And the long-arc question: how much of the trajectory should the system steer without asking? Au Autonomy is the dial. At zero, every step requires confirmation. At one, the system completes entire workflows unattended. Trajectory engineering is what makes turning that dial up safely possible — because the further you turn it, the more the quality of unobserved trajectories has to be defensible by construction, not by hope.

The thread

Six leverage surfaces and one owner. That is the working definition of trajectory engineering in V.E.T.S.: every input chosen on purpose, every bound installed on purpose, every default improved on purpose, every trajectory inspectable on purpose, owned by an agent whose scope is clear. The two colic answers we started with weren’t produced by a better model and a worse model. They were produced by a better-shaped context and a worse-shaped one. The model is the same. The engineering is the difference.

Every minion in V.E.T.S. is a managed trajectory. The next tab shows how they coordinate. See the Minion Hierarchy →

A veterinarian drives out to a ranch where 200 head of cattle need pregnancy checks, vaccination records updated, and a billing arrangement set up before the herd moves to summer pasture. She opens V.E.T.S. on her tablet and speaks naturally: "200 head, pregnancy check, update vaccinations, set up billing for the season." That sentence enters the system as a Pr Prompt — carrying context about who is asking, where they are, and what they need. The system immediately converts her words into mathematical meaning through Em Embeddings — turning "pregnancy check 200 head" into a vector that sits close to herd health protocols, reproductive procedures, and bulk billing templates.

That embedded request reaches Dr. Dolittle Dr. Dolittle, the wise owl who oversees the entire minion team. He doesn't treat animals or process invoices — he listens, understands context, and decides who should handle what. This is a complex, multi-part request, so Dr. Dolittle engages Th Thinking Models to reason step by step: veterinary care is the primary need, herd organization is a prerequisite, and billing is downstream. His understanding of these relationships is powered by Lg Large Language Models that have been trained on vast veterinary and operational knowledge, then grounded in V.E.T.S. data. Dr. Dolittle operates as a special kind of Ag Agent — a coordinator agent whose job is routing, not doing. You can see how Dr. Dolittle's orchestration works in the Orchestration Orchestration lesson, and explore the full roster of registered agents in the Registry Mission Control.

Dr. Dolittle routes the pregnancy check to Florence Florence, the compassionate nightingale who handles all medical and clinical work. Florence searches the knowledge base through Rg RAG (Retrieval-Augmented Generation), pulling pregnancy check protocols specific to this ranch's breed and history rather than relying on generic training data. Out in the field, the vet notices one cow with an unusual discharge and snaps a photo. Florence interprets the image through Mm Multimodal understanding, correlating the visual finding with the animal's history to flag it for closer examination.

When Florence activates on the patient history page, she doesn't start from zero. She "wakes up" already knowing which page the vet is on, which database tables are in scope, and what actions are available. This pre-loaded awareness is her MinionStart space — a snapshot of UI and data context that lets her assist immediately. She uses Fc Function Calling to pull the patient's history, check vaccination schedules, and look up herd-level reproductive trends — structured actions the AI takes on behalf of the vet. Meanwhile, Vx Vector Search compares the current case against indexed protocols, finding the most relevant pregnancy check procedures and flagging any breed-specific considerations. Each of the 14 minions has their own MinionStart spaces — 78 page mappings across the entire system — and Florence alone understands five clinical pages.

Florence finishes the pregnancy check notes and recognizes the rancher still needs an invoice. She doesn't try to handle billing herself — instead, the system evaluates a handoff. Efficient Sm Small Models handle the fast keyword matching against each minion's routing profile, saving the heavy reasoning for cases that need it. The result passes through Gr Guardrails — confidence thresholds that protect the routing decision. Above 0.80, the handoff happens seamlessly. Between 0.50 and 0.80, the user is offered a choice. Below 0.50, Dr. Dolittle steps back in. You can test this handoff evaluation yourself in the Test Harness Handoff Test Harness. The billing keywords match Penny Penny at 0.90 confidence — the cheerful bird who makes sure the numbers add up.

With 200 head to process, this isn't a one-minion job even within the care domain. Florence becomes a team lead — she coordinates Lassie Lassie to organize the herd records while Baxter Baxter sets up the new animal entries. This is the middle management tier: four team leads — Florence for Care, Clerk Clerk for Records, Penny for Business, and Oz Oz for System — each coordinating specialists within their domain through Ma Multi-Agent collaboration — which you can explore hands-on in the Multi-Agent Lab Multi-Agent Lab. All of this is built on proven Fw Frameworks — battle-tested patterns for prompt routing, retrieval pipelines, and response generation that ensure consistent quality across every minion in the hierarchy.

The same hierarchy serves different people in different ways. A visitor on this About page sees educational content — the narratives, the minion cards, the Periodic Table of AI. A logged-in rancher sees Florence on the patient history page, ready to assist with the next pregnancy check. An administrator sees the Dashboard Land of Oz — monitoring system health and using In Interpretability to see exactly why a recommendation was made, which documents were referenced, and where uncertainty exists. Before any of these interactions reach a real user, the system is stress-tested through Re Red-teaming — deliberately probing for weaknesses, hallucinations, and edge cases across the entire minion team. Three audiences, one minion hierarchy, each interaction tailored to the user's role and needs.

Today, minions wait for questions. The vet asks and Florence answers. But the system is growing toward responsible Au Autonomy in routine decisions. Imagine Florence automatically flagging that three animals from the same herd share similar symptoms — a pattern worth investigating. Or Penny generating a draft invoice the moment the last procedure is recorded. Or Lassie noticing a vaccination is overdue and scheduling the follow-up before anyone asks. Always with human oversight one click away, but handling the predictable work so the experts can focus on the exceptions. For rare conditions the team hasn't seen enough of, Sy Synthetic Data generates realistic but artificial examples — so the minions can learn to handle an uncommon complication without waiting for it to happen in the field.

Every correction the rancher or the veterinarian makes doesn't just fix one record — it teaches the entire team. The system continuously improves through Ft Fine-tuning — learning from every correction, every expert edit, every new protocol added to the knowledge base. Florence learns a better way to phrase a pregnancy check note. That knowledge propagates through the vector index, improving retrieval for every future interaction. The minions don't just serve users — they learn from them, getting smarter with every use, moving the whole hierarchy closer to the day when the predictable work runs itself and the experts focus entirely on what only they can do.

The last veterinarian logs off at 8 PM. The waiting room goes dark. But inside V.E.T.S., the work is just beginning. Every hour, around the clock, the vector pipeline quietly checks for stale content. When a vet corrects a pregnancy check protocol during the day, the system detects the change and regenerates its Em Embeddings — converting the updated text into mathematical meaning. Those fresh embeddings are pushed to the cloud index, immediately improving Vx Vector Search results for the next morning's queries. This hourly cycle never sleeps — 24 runs a day, 168 a week, silently keeping the knowledge base current.

Then at 2 AM, the main event begins. The Intelligence Pipeline fires — 26 automated steps organized into eight phases. Phase 1 is Learning: the system reviews how users interacted with minion greetings yesterday, applying Ft Fine-tuning adjustments based on what worked and what didn't. Efficient Sm Small Models handle the pattern matching quickly — analyzing greeting effectiveness and upgrading schemas without burning expensive LLM calls on routine classification.

Phase 2 is Content Generation — the heaviest lift of the night. The pipeline generates Pr Prompts that instruct Lg Large Language Models to write semantic summaries for documents that don't have them yet, extract keywords for search indexing, discover relationships between database objects, and generate help documentation for every minion. Each batch call is grounded through Rg RAG so the generated content reflects actual V.E.T.S. knowledge, not generic training data. Tonight: 10 new summaries, 10 keyword extractions, 10 relationship mappings, 14 minion help pages refreshed.

Phase 3 is Knowledge Enrichment. New stored procedures that developers wrote yesterday are synced into the TeamDoc document system and given AI-generated descriptions. The knowledge graph expands — 18 new relationships discovered tonight linking procedures to the tables they read, the views they populate, and the minions that use them. These connections are extracted through Fc Function Calling — the same structured tool use that powers daytime interactions, now running in batch mode against the database schema. Tags are generated for untouched documents, and where content includes images or diagrams, Mm Multimodal understanding ensures visual content is indexed alongside text.

Phase 4 is Quality Calibration. Not all knowledge is equal, and the pipeline knows it. Confidence scores are graduated — documents that have been stable for weeks and verified by experts get promoted from 0.70 (AI-generated) to 0.80 or 0.90 (human-verified). These thresholds act as Gr Guardrails for retrieval: when a minion searches for an answer, higher-confidence documents rank first. Token estimates are recalculated, categories refined, and content is distributed to the minions whose domains match. In Interpretability is built into every score — you can always trace why a document ranks where it does, which metrics contributed, and when the score last changed.

Phases 5 and 6 handle Reorganization and Hygiene. Documents are checked for structural health — should this 4,000-word chunk be split? Is that procedure description still attached to the right parent? Complexity scores and performance metrics are recalculated across the entire index. Then the cleanup crew sweeps through: orphaned index entries that point to deleted documents are removed, the learning pipeline promotes battle-tested corrections into permanent knowledge, and chat transcripts from the past week are mined for examples that teach minions how real users phrase their questions. All of this runs on proven Fw Frameworks — the same patterns for batch processing, error handling, and progress logging that ensure every step either succeeds cleanly or fails without corrupting the next. For rare conditions the system hasn't encountered enough of, Sy Synthetic Data fills the gaps — generating realistic training examples so the AI can recognize uncommon patterns without waiting for them to occur naturally.

Phase 7 is Evaluation — the system stress-testing itself. Every chunk in the knowledge base is classified by type and domain, then subjected to quality evaluation by Th Thinking Models that reason through each document step by step: Is this content accurate? Is it complete? Does it contradict anything else in the index? This is automated Re Red-teaming — the system probing its own knowledge for weaknesses, hallucinations, and redundancies before they reach a real user. Tonight: 50 chunks classified, 25 evaluated, orphaned vectors cleaned from the cloud index, and redundant content flagged for consolidation.

Phase 8 is Capability Maps — the final phase that connects everything back to the minions. UI elements across every page are enriched so each Ag Agent understands not just what data exists but what the user can do on each screen. Then capabilities are refreshed for any stored procedures whose definitions changed since yesterday — if a developer added a new parameter to a billing proc, Penny's capability map updates overnight so she knows about it by morning. This is Ma Multi-Agent coordination at the infrastructure level: 14 minions, 78 page mappings, all kept in sync by the pipeline.

By 3 AM, the pipeline is done. Summaries written, keywords extracted, knowledge graph expanded, confidence recalibrated, quality evaluated, capabilities refreshed. The system is measurably smarter than it was at 9 PM. You can see the results in the Night Shift Dashboard Night Shift Dashboard — processing counts, queue depths, error rates, and 30-day trends all tracked automatically. This is responsible Au Autonomy in action: 26 steps, eight phases, zero human intervention. The intelligence that powers the daytime — every search result Florence returns, every handoff Dr. Dolittle routes, every confidence score Oz monitors — was built, refined, and verified while the ranch was sleeping.

A rancher walks into the clinic and speaks one sentence. To a human, it sounds simple. To the AI, it contains five distinct tasks spanning five different domains — medical records, document management, herd logistics, billing, and contact management. This is where multi-agent orchestration earns its keep.

The request lands with Dr. Dolittle Dr. Dolittle, the coordinator Ag Agent whose job is routing, not doing. Dr. Dolittle's Th Thinking Models analyze the request step by step, identifying the implicit dependencies: the health certificate must come before the sale, records must transfer before the herd updates, and the invoice can't generate until the transfer price is established. Lg Large Language Models power this decomposition, guided by carefully constructed Pr Prompts that tell the coordinator: break this into subtasks, identify which minion handles each one, and determine the order of operations.

The routing engine fires. Each subtask is evaluated against every minion's capability map using Em Embeddings and Vx Vector Search — not just keyword matching, but semantic understanding of what each minion can do. “Transfer his records” doesn't contain the word “documentation” but the system knows Clerk handles record management. Sm Small Models handle this fast classification without the latency of a full LLM call. Confidence scores act as Gr Guardrails: above 0.90, the handoff happens silently; between 0.70 and 0.90, the user is offered a choice; below 0.70, Dr. Dolittle keeps the request and asks for clarification. You can test this routing logic in the Test Harness Test Harness.

Step 1: Health Certificate. Florence Florence receives the first subtask. Before a bull can be sold, the buyer needs a health certificate. Florence searches the animal's medical history through Rg RAG — pulling vaccination records, test results, and treatment history from the knowledge base. She uses Fc Function Calling to query the patient history tables directly, and where lab results include scanned images, Mm Multimodal understanding reads them alongside the text data. The health certificate is assembled and marked complete.

Step 2: Record Transfer. Florence signals completion and Clerk Clerk picks up the next subtask. The bull's ownership records, breeding history, registration papers, and associated documents need to move from the seller's account to the buyer's. Every field change is logged with full In Interpretability — who changed what, when, and why, creating an audit trail that satisfies both the rancher and any regulatory review. The transfer runs on proven Fw Frameworks that ensure data integrity: if any step in the transfer fails, the entire operation rolls back cleanly rather than leaving records in an inconsistent state.

Steps 3 & 4: Herd Update and Invoice. With the transfer complete, two tasks can now run in parallel — this is Ma Multi-Agent coordination at its most practical. Lassie Lassie adjusts the herd count — the bull moves from the active inventory to the sold category, breeding group assignments update, and any pending herd tasks referencing that animal are flagged for review. Simultaneously, Penny Penny generates the invoice from the agreed sale price, applies any applicable fees, and queues it for the buyer. This parallel execution is responsible Au Autonomy — the system handles routine steps independently, only escalating to a human when something unexpected arises.

Step 5: Buyer Contact. Baxter Baxter updates the buyer's account with the new animal record and ensures the contact information is current. The chain is complete: health certificate issued, records transferred, herd updated, invoice generated, buyer notified. Five minions, one coordinated workflow, zero context lost between steps.

The full chain is validated through automated Re Red-teaming — test scenarios probe each handoff point for failures: What if Florence can't find vaccination records? What if the buyer's account doesn't exist? What if Penny generates a $0 invoice? For edge cases the system rarely encounters, Sy Synthetic Data generates realistic test scenarios — a bull with an expired health cert, a herd with conflicting counts, a buyer in a different tax jurisdiction — so the chain can be stress-tested without waiting for real-world failures. Every completed chain feeds back into the system through Ft Fine-tuning: which routing decisions worked, which handoffs were accepted, where users intervened. The chain gets smarter with every transaction. You can watch the coordination in real time in the Multi-Agent Lab Multi-Agent Lab.