Agentic AI

Classify a software solution as a deterministic workflow, an LLM-assisted workflow, or an autonomous agent from its control flow.

Diagram the perceive–reason–act–observe loop for a software-maintenance task.

Explain why probabilistic model outputs require deterministic checks before code changes are accepted.

Configure OpenAI credentials securely for local C# and Python applications.

Send an OpenAI Responses API request from C# and inspect its response metadata.

Reproduce a basic OpenAI request in Python and relate its components to the C# implementation.

Write an instruction hierarchy for a coding agent with explicit goals, boundaries, and completion criteria.

Separate trusted instructions from untrusted issue and repository content in a model request.

Select repository context for a request within a fixed token budget.

Choose an OpenAI model for a task using quality, latency, context-window, and cost requirements.

Request a schema-constrained coding plan from a C# application.

Validate a schema-constrained model response and handle validation failure.

Define an equivalent structured-response model with Python and Pydantic.

Design a narrow tool schema with unambiguous parameters and return values.

Implement a read-only repository tool callable from a C# agent.

Dispatch an OpenAI tool call and return the tool result to the model.

Implement the same tool-calling cycle in a minimal Python prototype.

Represent an agent run as explicit state rather than relying only on conversation history.

Stop an agent loop using iteration, time, and token limits.

Convert tool failures into structured observations that support safe recovery.

Create an isolated Git branch or worktree for an agent run.

Build a repository inventory that excludes ignored, generated, binary, and oversized files.

Resolve requested file paths without allowing access outside the repository workspace.

Search a repository for symbols and references using deterministic code-search tools.

Summarize a repository’s projects, dependencies, and test layout using tool-derived evidence.

Select the smallest set of files needed to investigate a maintenance issue.

Use Git status and diff output to identify every change made during an agent run.

Divide source code into retrieval units that preserve symbol and file metadata.

Generate OpenAI embeddings for repository content and store them with versioned metadata.

Retrieve code with lexical search for exact identifiers and error messages.

Retrieve conceptually related code with vector similarity search.

Combine lexical and vector results into a hybrid retrieval ranking.

Filter and rerank retrieved code by path, language, symbol, and repository state.

Measure retrieval recall with a small set of known code-navigation questions.

Update a repository index incrementally after a commit changes selected files.

Convert a maintenance issue into testable acceptance criteria.

Detect missing requirements and formulate a focused clarification request.

Produce a dependency-ordered implementation plan grounded in repository evidence.

Represent a coding-agent workflow as a state machine with explicit transitions.

Checkpoint an agent run so it can resume without repeating completed tool actions.

Route deterministic operations to code and ambiguous decisions to the model.

Place human approval gates before high-impact actions.

Record the evidence used to approve or reject an agent-proposed plan.

Request a code change as a machine-readable patch rather than unrestricted prose.

Validate patch paths and hunks before applying a model-generated patch.

Apply an approved patch inside an isolated Git workspace.

Run build and test commands through an explicit command allowlist.

Convert compiler and test failures into concise evidence for the next model step.

Implement a bounded patch–build–test–repair loop.

Reject a patch that changes files outside the approved plan.

Restore the workspace cleanly after an unsuccessful agent run.

Map the previously built agent loop to Semantic Kernel concepts without changing its safety boundaries.

Register typed C# repository functions as Semantic Kernel plugins.

Persist and restore Semantic Kernel workflow state across process restarts.

Implement an equivalent tool-using prototype with the OpenAI Agents SDK for Python.

Explain the roles of MCP hosts, clients, servers, resources, and tools.

Expose a read-only repository capability through an MCP server.

Connect an agent to an explicitly trusted MCP server and restrict the tools it may invoke.

Decide whether a task needs one agent or specialist agents using complexity and coordination costs.

Create a representative evaluation set from software-maintenance issues and expected outcomes.

Define task-success metrics for planning accuracy, tool use, patch correctness, and test results.

Unit-test agent tools without making live model calls.

Replay recorded model and tool interactions to reproduce a failed run.

Use deterministic checks to grade buildable and test-passing patches.

Design a rubric for aspects of code quality that require model-assisted grading.

Compare two agent configurations while controlling the evaluation dataset.

Add an agent evaluation suite to a continuous-integration pipeline.

Threat-model the data sources, tools, permissions, and outputs of a coding agent.

Demonstrate how repository content can attempt indirect prompt injection.

Apply instruction isolation and tool policy checks to resist prompt-injection attempts.

Prevent path traversal, symlink escape, and unauthorized file access.

Prevent shell injection by separating approved commands from model-supplied arguments.

Run code changes and tests in a disposable least-privilege sandbox.

Detect and redact secrets before content is sent to a model or written to logs.

Require explicit approval for destructive, external, or credentialed actions.

Emit a structured trace that links each model decision, tool call, and state transition.

Attach correlation identifiers to all events from a single agent run.

Retry transient OpenAI and infrastructure failures with bounded exponential backoff.

Make tool operations idempotent so retries do not duplicate side effects.

Enforce per-run limits for time, tokens, cost, and tool invocations.

Persist run state and artifacts for audit, diagnosis, and recovery.

Control worker concurrency in response to model rate limits and repository capacity.

Package the .NET agent as a containerized API or background worker with externalized secrets.

Define the supported issue types, excluded actions, and measurable success criteria for the capstone agent.

Connect a selected repository to an isolated, indexed agent workspace.

Implement issue triage and evidence-grounded context retrieval as one workflow.

Implement a reviewable plan with an approval checkpoint before code modification.

Integrate the bounded patch–build–test–repair workflow into the agent.

Publish an approved branch or pull request with a change summary and verification evidence.

Run the evaluation and security test suites against the completed agent.

Deploy the agent as a monitored job and diagnose one end-to-end run from its trace.