I build AI agents by asking an old question: whose agent are they?

I use coding agents every day, from the principal side of the relationship. What I think AI agents should be — and what they should refuse to do — comes from that experience, then from law, economics, and literature.

You learn what a good agent is by being responsible for what a bad one produces.

The repositories below are small, opinionated answers to the question of for whom an AI agent acts. Each has a defined principal, a bounded scope, and a refusal to substitute its judgment for the principal's.

An agent for the contract reviewer, not the drafter.

It does not decide whether a contract is acceptable. It returns the questions a well-informed reviewer should ask before making that judgment.

Principal: contract reviewer
Artifact: verification questions
Boundary: no verdict

An observable Agentic RAR runtime for the reader trying to make sense of a noisy domain.

It does not recommend what to do. It turns canonical and emerging signals into interpreted rules and reference frames, while keeping reasoning structure visible through typed artifacts, reflection, checkpoints, and workflow status.

Principal: domain reader / decision-maker
Artifact: interpreted rules
Boundary: no prescription

A learning-design label for exploring the same question in self-directed study.

A study tool should not pretend to be the learner. It should structure attention, reduce friction, and help the learner see what to practice next.

Principal: learner
Artifact: study frames, practice scaffolds, metacognitive prompts
Boundary: no substitution for learning

• LLMs as controlled transformation components, not the center of the system: reasoning structure belongs in retrieval, schemas, reflection, checkpoints, and workflow state.
• Structure as engineering substrate, not the surface the user reads.
• Decision-grade artifacts over confident answers: questions, rules, traceable evidence, and reference frames.
• Explicit state machines over open-ended loops when reproducibility, attribution, and debugging matter.
• Abstention as a feature: a useful agent must know when not to answer.
• No-disclaimer-by-design: the agent avoids judgments that would require warning users not to trust them.
• Provider contracts over provider lock-in: typed boundaries, observable workflows, and replaceable infrastructure.
• AI tools as principal-bounded delegation: I use coding agents daily, and the boundaries I demand from them are the boundaries I build into mine.

I am working toward Georgia Tech OMSCS to restate these commitments in more formal ML and systems language: calibrated abstention, frame-lending representations, controlled transformation pipelines, and agent workflows with explicit decision boundaries.

Applied AI engineering in domain-heavy contexts. The thesis above is what I have come to think after trying to make LLMs useful inside real workflows without making them the center of those workflows.

My formation crosses two traditions: a liberal arts background and ongoing graduate study in computer science. The questions about agency, representation, and the structure of judgment in this portfolio come from the first; the way they are implemented as schemas, state machines, and typed pipelines comes from the second.

I am interested in where AI agents should stop — and how that boundary can be made explicit in code.