Anthony Adamo's Portfolio

The biggest lesson I’m taking away is that building software isn’t only about making something work, it’s about making something reliable and measurable. When I started the program, I focused on the features and implementation, and by the end, I’m thinking more like an evaluator and I treat evidence as part of the product.

My capstone project became the clearest representation of this change. I built a context-aware NPC Agent for Minecraft that combines retrieval-augmented generation with environmental perception, persistent memory, and constrained behavior execution. The system uses a Mineflayer agent connected to a Python backend, and it was designed so that the agent could act in the world safely while generating telemetry and survey data that I could use to support conclusions.

As I reviewed my earlier coursework and compared it to my final capstone, I noticed that the program changed how I approach both architecture and evaluation. I became more intentional about separating systems into modules, and logging the correct signals so I could interpret the outcomes conservatively. I also learned how much evaluation depends on task design. Some tasks were too static to show any meaningful differences, while the behaviors that were more prone to failure revealed the value of memory and retrieval more clearly.

Each course contributed to the final result by strengthening either my engineering foundation or my ability to evaluate what I built. Some classes helped with core software design and implementation, while others pushed me to think more critically about measurement.

Going forward, I plan to continue improving the project as a portfolio piece and expand its evaluation. My next steps include refining the performance, testing with more complex tasks where memory matters more, and scaling the design to produce stronger evidence. Overall, I’m leaving the program with a clearer understanding that building software and evaluating software are intertwined when the goal is to produce work that holds up under scrutiny.

This month’s goal was to advance the intelligence and responsiveness of my NPC agent by enhancing the action execution, integrating feedback, and stabilizing the system for milestone testing. I focused improving the communication between Minecraft and the backend language model, and validating the NPC behavior through targeted testing commands.

To accomplish this, I worked within a Mineflayer architecture (originally starting with Fabric), implemented new command handlers, refined the recovery and action sequences, and profiled the performance using Clinic.js. This iteration strongly focused on accuracy, repeatability, and verifying the NPC’s ability to interpret tasks and adapt to player feedback.

A core issue I faced early in the month was inconsistent decision responses from the NPC after executing several tasks. My strategy for solving this involved stepping through each component, such as commands, action handlers, dialogue routing, and queue logic, to isolate where state was dropping or being overwritten. This led to multiple refinements in the command structure and error handling, which resulted in more predictable behavior across sessions.

Successes:

• I successfully built and tested all the milestone commands for NPC evaluation.
• The NPC is now far more stable during repeated test sessions.
• Backend routing improvements increased the clarity and usefulness of LLM responses.
• Version control and release management have been consistent throughout the month.

Problems:

• Several early errors in command handling caused ambiguous or repeated fallback responses.
• Pathfinding tests initially produced inconsistent movement due to incomplete recovery logic.
• The migration away from Fabric introduced work that delayed testing cycles.

Going Forward:

• Continue to expand the automated test scenarios to identify regressions early.
• Maintain a higher update frequency with my advisor to validate feature direction.
• Begin organizing performance metrics earlier in each milestone to reduce pressure.

Additional Reflection

• Time Utilization: I managed my tasks effectively, though some refactoring work took longer than expected due to the architectural changes.
• Info Gained: This month improved my understanding of sequencing, backend routing to LLMs, and NPC state management.
• Course Application: Concepts from AI programming, software architecture, and distributed systems were applicable during backend NPC communication.
• Preparation: With the feedback and testing commands in place, I am positioned to begin the memory learning and evaluation cycles planned for the next milestone.