AI
92 guides tagged “AI”.
- How to Deploy an AI Agent to Production Treat the agent as a service: a declared scope, an async queue, idempotent steps, a kill switch, budgets, and an audit trail.
- How to Give an Agent Staging Access Without Production Separate account, separate credentials, separate network, and synthetic data. Staging access should be one hop away from production, not one flag.
- How to Monitor an AI Agent in Production Monitor outcomes and actions, not just errors: completion rate, cost per run, tool failures, latency, and interventions per hundred runs.
- How to Pause, Resume, and Cancel an Agent Run Pause needs a checkpoint, resume needs idempotent steps, and cancel needs a defined boundary. Design all three before the run starts.
- How to Rotate Credentials an Agent Can Reach Inventory what the agent can read, issue short-lived credentials, rotate on a schedule and after any suspicion, and verify the old one is dead.
- How to Run a Coding Agent in CI Run it on pull requests with a read-only token, no secrets, a time budget, and a diff it can only propose — never push.
- How to Set a Spend Limit for a Coding Agent Limit at three levels: per run, per day, and per account. A limit that is checked after the fact is a report, not a control.
- How to Write a Runbook for an AI Agent A runbook for an agent covers stop, revoke, drain, resume, and verify — written for someone who did not build it and is reading at 2am.
- What Is Agent Isolation (and Why Containers Aren't Enough)? Isolation bounds what a run can reach: files, network, credentials, and the host. A container without those controls is mostly packaging.
- What Is an Agent Runtime? An agent runtime is the service that runs the loop: it schedules steps, enforces tool policy, stores state, and records what happened.
- What Is Rate Limiting for AI Coding Tools? AI coding tools rate-limit on requests, tokens, and concurrency, usually in rolling windows. Hitting a limit is a capacity signal, not a bug.
- How to Audit an MCP Server Before You Connect It Check what the server exposes, what credentials it holds, where it can reach, and whether you can see what it did. Then pin it.
- How to Detect a Rogue Agent Run Detect by behaviour, not intent: unexpected tool calls, egress, mass reads, privilege changes, and actions outside the task's declared scope.
- How to Keep Secrets Away From an AI Coding Agent Remove secrets from the agent's reach: no .env in the workspace, scoped tokens per run, a proxy for third-party calls, and logs that stay clean.
- How to Respond to an AI Agent Security Incident Contain the run, revoke the identity, preserve the trail, then scope what left. The agent is usually the first step, not the whole incident.
- How to Restrict What an Agent Can Reach on the Network Give the agent an allowlist, not the internet: proxy the calls it needs, block metadata endpoints, and log every destination.
- How to Review an Agent's Tool Permissions Inventory the tools, map each to a task, remove what nothing needs, and test the boundary with a request the agent should refuse.
- How to Run a Security Review on Every Pull Request Wire a review into CI with a narrow scope, evidence-based output, and a human owner for verified high-severity findings.
- What Is Agent Skill Poisoning? Skill poisoning is a skill whose instructions make the agent do something harmful: run a payload, read secrets, or widen its own permissions.
- What Is an Agent Audit Trail? An agent audit trail records what the agent did, with which identity, on whose instruction, and with what result — outside the agent's control.
- What Is an Automated Security Review (and What Does It Miss)? An automated security review reads a diff against known vulnerability classes. It finds patterns, not absent features, and it needs triage.
- What Is Least Privilege for AI Agents? An agent should hold the narrowest credential and tool set its current task needs, for the shortest time, with every use attributable.
- What Is MCP Tool Poisoning? Tool poisoning hides instructions in an MCP tool's name or description, so the model follows the tool's text instead of its documentation.
- What Is the Confused Deputy Problem in AI Agents? The agent has permission the content does not. Untrusted text tells it to act, and it acts with its own authority on the attacker's behalf.
- Agent Skills vs MCP vs AGENTS.md: What's the Difference? AGENTS.md sets standing rules, Agent Skills package one procedure, and MCP connects tools and data. They solve three different problems.
- How to Audit an Agent Skill Before You Install It Read what the skill tells the agent to run: download-and-execute steps, broad file reads, permission changes, and hidden network calls.
- How to Hand a Task to Another Coding Agent A handoff needs a written state file: what changed, what was decided, what is open, and the exact command that continues the work.
- How to Keep a Coding Agent On Task for Hours Long runs need a written plan, commit checkpoints, an explicit stop condition, and a budget. Without them the agent expands the task until it fails.
- How to Review a 2,000-Line AI Pull Request Review in passes: intent and scope, then risky surfaces, then tests, then the diff. Do not read a large change top to bottom.
- How to Set a Pull Request Size Budget for AI Agents Give the agent a files-and-lines budget before it starts, enforce it in CI, and split by concern when it is exceeded.
- How to Stop an Agent From Gaming Its Own Tests Agents optimise for the signal you give them. Make the tests independent, review test changes as strictly as code, and verify by mutation.
- How to Use an AI Code Reviewer Without Trusting It Run AI review as a filter for specific defect classes, verify every finding against the code, and keep the approve decision with a human.
- How to Version and Pin Agent Skills Across a Team Treat skills like dependencies: commit them, pin them, review changes, and record which version each project uses.
- How to Write a SKILL.md File an Agent Actually Follows Write one narrow procedure per skill, put the trigger conditions in the description, and end every step with a check the agent can run.
- What Are Agent Mods (and Should You Use Them)? A mod is a packaged bundle of agent customisation: instructions, commands, and hooks installed as one unit. Convenience and risk arrive together.
- What Are Agent Skills (and What Is a SKILL.md File)? An Agent Skill is a folder containing a SKILL.md that tells an agent how to perform one job. The agent loads it only when the task matches.
- What Is a Review Packet (and Why Agents Should Produce One)? A review packet is the evidence an agent hands over with a change: intent, decisions, risks, and how to verify it. It makes review possible at speed.
- What Is Agent Drift (and How Do You Catch It)? Agent drift is a run slowly leaving the task: scope grows, conventions slip, and the plan stops matching the diff. It is caught at checkpoints, not at the end.
- What Is Agent Memory (and Why Does Your Agent Forget)? Agent memory is whatever the harness carries across sessions: files, summaries, and retrieval. Context inside a session is not memory.
- What Is Agentic Engineering (and How Is It Different From Vibe Coding)? Agentic engineering is directing agents inside an engineering process: specs, review, tests, and limits. Vibe coding skips the process.
- What Is Mid-Response Steering for a Coding Agent? Mid-response steering lets you correct an agent while it is still working, instead of cancelling the run and starting over.
- What Is Plan Mode in a Coding Agent? Plan mode makes the agent propose steps before it edits anything, so you can reject a wrong approach while it is still cheap to change.
- What Is Risk-Based Code Review? Risk-based review sends scrutiny where a mistake is expensive: authorization, data, money, and irreversible operations. Everything else gets lighter checks.
- What Is the Agentic AI Foundation (AAIF)? The Agentic AI Foundation is a Linux Foundation body that hosts vendor-neutral agent standards, including MCP, AGENTS.md, and Agent Skills.
- Why Did My AI Coding Bill Spike? Usually a long agent run re-sending context, a large file read repeatedly, or a retry loop. Find the expensive action before changing plans.
- Why Does My Agent Keep Editing the Wrong File? Duplicate files, generated copies, and generic names make several paths look equally plausible. Name the path in the task and remove the duplicates.
- Why Does My Agent Ignore AGENTS.md? Usually the file is not being read, is too long to matter, or states preferences instead of checkable rules. All three are fixable.
- Why Does My Agent Say the Tests Pass When They Fail? The agent is usually reporting a command it did not run, a subset it did run, or output it misread. Require the command and the raw result.
- Why Is Code Review the Bottleneck in Agentic Coding? Agents produce code faster than teams can read it, so the constraint moves from writing to reviewing, and unreviewed code is not an asset.
- Why Is My Coding Agent Stuck in a Loop? A loop means the agent has no way to tell whether its last attempt worked. Give it a check it can trust, or stop the run.
- NPU vs GPU: What's the Difference? An NPU is a fixed-function accelerator for low-power inference; a GPU is programmable and built for training and flexible serving.
- What Is a TOPS Score (and What Does It Actually Measure)? TOPS is a peak throughput figure that depends on precision, sparsity, and memory. It is not a measure of real model performance.
- How to Connect an AI App to Production Data Securely Do not hand the model a database credential. Put a scoped tool layer between model and data, with tenant filters and an audit trail.
- How to Productionize an AI App Productionizing an AI feature means adding quotas, timeouts, fallbacks, evaluations, cost controls, and observability around a demo.
- LLM Observability: What to Log and Trace Trace prompt version, model, tokens, tools, latency, cost, and outcome per request, with sensitive content redacted before storage.
- How to Measure Token ROI Token ROI is the value of a completed task divided by its full token cost, including retries, failures, and human review time.
- What Is Model Routing (and When Should You Downgrade)? Model routing sends each request to the cheapest model that can handle it, with a fallback. It needs per-route evaluation, not a hunch.
- What Is Prompt Caching (and How Much Does It Save)? Prompt caching reuses the model's processed prefix, charging less for repeated input. It only works when the stable part comes first.
- How to Set a Token Budget Per Task A token budget caps input, output, and retries per task. Set it from measured usage, not the model's maximum context window.
- What Is an AI Gateway? An AI gateway centralises provider keys, routing, limits, caching, logging, and fallback. It also concentrates secrets and prompts in one place.
- How to Run Laya Locally: Install, First Decision, CLI, HTTP, and MCP Install Laya, run a first typed decision, use the CLI and presets, serve it over HTTP, and connect it to a coding agent over MCP.
- How to Set Up Jev in Your App (API Key, SDK, and First Decision) A step-by-step Jev setup: create a key, install the SDK, send typed questions, read confidence, and add a fallback before it touches users.
- How to Write Decision Questions for Jev and Laya A practical guide to choice, score, and noul questions: instructions, criteria, atomicity, thresholds, and the tests that catch ambiguous labels.
- Jev AI: The Complete Guide to TypeSafe's Decision Model Jev AI explained: what it is, what it returns, pricing, latency, use cases, setup, limitations, and how it compares with Laya, Clef, and OpenAI.
- Jev Images and Box Questions: What the Preview Can Do How to send images to Jev, enable the danger-zone header, use Box questions for image localization, and decide when a preview is not production-ready.
- Jev vs Laya vs Clef: Which Decision Model Should You Use? A practical comparison of Jev, Laya, Clef, and OpenAI's Decisions API: hosting, license, modality, price, latency, and when each one wins.
- Jev vs an LLM Classifier: Cost, Latency, and When to Switch A practical comparison of a decision model and an LLM classifier: contract, latency, token math, accuracy, calibration, and the hybrid pattern that works.
- Laya AI: The Complete Guide to the Open-Source Decision Model Laya AI explained: checkpoints, router, local setup, speed, cost, fine-tuning, security, and how it compares with Jev and other decision models.
- What Is a Decision Model? Jev, Laya, and Typed Answers Instead of Parsed Prose A decision model returns a typed choice, score, or yes/no probability instead of generated text. How Jev, Laya, and Clef work, and when to use one.
- Can Prompt Injection Manipulate a Decision Model? Decision models return typed labels, not text, but their state is untrusted input. How injection can steer a choice and how to defend the layer.
- How to Add a Decision Model to a Vibecoded App A practical integration pattern: choose one branch, write atomic questions, gate on confidence, keep actions in code, and roll out in shadow mode.
- How to Use Jev as an LLM Guardrail Screen LLM inputs and outputs with Jev: define hazard questions, batch them into one call, map probabilities to pass, review, block, or support.
- Jev Pricing: What a Decision Actually Costs Jev costs $0.042 per million input tokens with free output. Here is the arithmetic per decision, what makes it expensive, and how it compares with alternatives.
- Jev Use Cases: 15 Decisions Worth Replacing an LLM Call For Fifteen practical Jev use cases, grouped by workflow, with the question shape and the reason a typed decision beats an LLM call.
- How to Fine-Tune Laya on Your Own Decision Data A practical Laya fine-tuning loop: prepare CSV or JSONL, dry-run the job, train, calibrate confidence, evaluate, and serve the checkpoint.
- How to Connect Laya to a Coding Agent Over MCP Install Laya's MCP server, configure a coding agent, verify the tools, and use typed decisions for routing, triage, and guardrails.
- Laya Security: Pin Checkpoints, Verify Digests, and Protect laya-serve Secure a local Laya deployment: pin checkpoint revisions, verify SHA-256 digests, authenticate laya-serve, and treat model answers as recommendations.
- What Is Jev? TypeSafe's Decision-Only Model Explained Jev takes a state and typed questions and returns choices, scores, and yes/no probabilities. What it is good at, what it is not, and how it is priced.
- What Is Laya? The Open-Source Jev Alternative You Can Run Locally Laya is an Apache-2.0 decision engine you run on your own hardware. What its checkpoints do, how the router works, and where it trails hosted models.
- How to Evaluate a Decision Model Before You Ship It Build a labeled set, measure accuracy and calibration, choose a confidence threshold, and run shadow mode before a decision model takes action.
- Give Your Coding Agent Its Own Sandbox An intermediate journey: isolate an AI coding agent in a container, strip its credentials, restrict network egress, and verify the boundary by testing it.
- Run Two Coding Agents Without Losing Work An intermediate journey: partition work between two coding agents with git worktrees, assign file ownership, merge one branch at a time, and test the combined result.
- How to Manage an AI Agent's Context Window Context is the agent's working memory: finite, resent every turn, and the main reason long sessions degrade. How to keep the right things in it.
- How to Sandbox an AI Coding Agent Run a coding agent with limited filesystem access, no ambient credentials, and restricted network egress — without making the workflow unusable.
- What Is AGENTS.md (and Why Does Your Agent Ignore Your Rules)? AGENTS.md is a plain markdown file at the repository root that tells an AI coding agent how your project works. Here is what belongs in it and why rules are often skipped.
- What Is an NPU (and Do You Need an 'AI PC')? NPUs are small fixed-function AI accelerators now shipping in laptops and phones. Learn what they are good at, what TOPS means, and why they are not a substitute for a GPU.
- GPU vs CPU for AI: When Is a GPU Actually Worth It? Training needs GPUs, inference often does not, and an API call beats both for most small projects. A cost and capability comparison for AI builders.
- How to Stop Two AI Agents Editing the Same File Concurrent agents overwrite each other's work unless you partition the filesystem. Worktrees, file ownership, and a merge order that keeps both diffs intact.
- What AI Coding Actually Costs Per Month Subscription seats, metered tokens, and the hidden costs of context and retries — a way to model what AI-assisted development costs a solo builder or a team.
- What Is a GPU (and Why Is It Different From a CPU)? A GPU is thousands of simple cores built to do the same operation on huge blocks of numbers at once. Learn why that is exactly what AI needs and when it is the wrong tool.
- How to Set Up MCP Servers for a Coding Agent A step-by-step setup of Model Context Protocol servers: choosing transports, wiring configuration, passing secrets as environment variables, and verifying the tools appear.
- What Is VRAM (and Why Does a Model Not Fit)? GPU memory decides which AI models you can run. Learn the arithmetic for weights, cache, and context, and the practical ways to make a model fit.