HPAT Trust Framework — Agents That Earn Autonomy

High Performance AI Teams — agents don't act because a trigger fired, they act because they earned trust. Autonomy through outcomes, feedback, and memory. Built in a dental practice and no programmer.

Comment

Inspiration

I'm a dentist. Not a developer. I run a dental practice in Switzerland with a small team — assistants, hygienists, a practice manager. Six months ago, I started building software with AI. Not because I wanted to code, but because my team had problems that no off-the-shelf software could solve.

The moment that sparked this project: My dental assistant was helping me during a root canal treatment. The phone rang. She had to leave the patient, walk to the front desk, answer the call, schedule an appointment, walk back — and try to remember exactly where we left off. This happens 15-20 times per day. Every interruption is stress, risk, and wasted time.

I thought: What if she had an AI teammate that could handle this? Not a chatbot. Not a voice assistant. A teammate — one that knows the practice, knows her workflow, knows when to step in and when to stay quiet.

That's when I realized: the hard part isn't building the agent. It's building trust between the human and the agent.

What it does

HPAT (High Performance AI Teams) is a framework where AI agents earn autonomy through proven outcomes — not static triggers.

Traditional agents fire when a condition is met: on: merge_request, on: pipeline_failure. HPAT agents fire when they've earned the right to act. Trust is the trigger.

The Trust Stack has four levels:

  • Trust 0 — Observe: The agent watches, learns, asks questions. Every action requires human approval. "I noticed you get interrupted by phone calls often. Should I help with that?"
  • Trust 1 — Assist: The agent proposes and waits for confirmation. "Someone is calling about an appointment. I've drafted a response — should I send it?"
  • Trust 2 — Act & Report: The agent handles the task and reports afterward. "I answered the call and scheduled the appointment for Thursday 10am. Here's the summary."
  • Trust 3 — Own: The agent handles it. The human sees it in the weekly report. The phone rings and nobody even thinks about it anymore.

Trust is earned per category — an agent can be Trust 3 for phone calls but Trust 0 for treatment planning. Trust goes up through positive outcomes and goes down through mistakes or negative feedback.

The Second Dimension: Role

Trust determines how much autonomy the agent has. But there's another axis: Role determines how the agent relates to the human.

  • Apprentice → Jarvis as Trainer: Teaches, challenges, asks "What would you do?" before answering. Every interaction is a learning opportunity. Even at Trust 3, Jarvis shows the apprentice how the task was done.
  • Team member → Jarvis as Assistant: Supports, unburdens, anticipates needs. Direct and efficient. Respects the human's expertise.
  • Leadership → Jarvis as Advisor: Challenges assumptions, aggregates data from across the team, surfaces patterns. Never just agrees — adds strategic perspective.

The same task plays out differently depending on role. When Jarvis handles a phone call:

  • For the apprentice: "I booked the appointment. Here's how I did it — next time, you try."
  • For the team member: "Done. Mrs. Weber, Wednesday 2pm."
  • For the CEO: "Done. That's 12 call interruptions today — trending up. Worth considering an online booking system?"

This two-dimensional framework — Trust × Role — is what makes HPAT unique.

How we built it

The HPAT Trust Framework is implemented on the GitLab Duo Agent Platform using:

Custom Agents:

  • Jarvis — the primary agent with a personality defined in soul.md, context awareness through AGENTS.md, and trust-level-aware behavior in its system prompt
  • Context Agent — reads issue history, labels, and past interactions to build situational awareness
  • Decision Agent — checks the trust level for the current task category and routes accordingly

Custom Flow: A YAML-defined workflow that orchestrates the trust-aware execution cycle: Trigger (mention or assign) → Context gathering → Trust level check → Route to human-in-the-loop (Trust 0-1) or autonomous action (Trust 2-3) → Outcome documentation → Feedback collection → Trust update

Trust Score Implementation:

  • GitLab Labels encode trust levels (trust::0 through trust::3) per task category (category::phone, category::inventory, category::scheduling)
  • GitLab Labels encode role levels (role::apprentice, role::team-member, role::leadership) per team member
  • The behavior matrix is Trust × Role: a 4×3 grid where every cell produces different agent behavior
  • Issue history serves as agent memory — every past interaction informs future decisions
  • Feedback reactions on issue comments update the trust score over time

Personality Layer:

  • soul.md defines Jarvis's character, communication style, and boundaries
  • AGENTS.md provides practice-specific context (team structure, workflows, domain knowledge)
  • The agent doesn't just execute — it communicates like a team member

Challenges we ran into

  1. Mapping a human concept (trust) to a technical system. Trust isn't binary. It's contextual, emotional, and built over time. Encoding this in GitLab labels and issue history is a simplification — but a useful one.

  2. The voice gap. In a dental practice, nobody types. Hands are gloved, eyes are on the patient. The natural interface is voice. GitLab is entirely text-based. Bridging this gap — speech to structured intent to GitLab issue — is the critical UX challenge.

  3. Starting from zero GitLab experience. I had never used GitLab before this hackathon. Everything was on GitHub. Learning the Duo Agent Platform, custom agents, flows, triggers, and the AI Catalog in under a week was intense — but it also proves the point: with AI teammates, anyone can build.

Accomplishments that we're proud of

  • A dentist built this. No CS degree, no prior GitLab experience, no traditional development background. The HPAT framework was designed and implemented using the same human-AI collaboration methodology it describes. This project is its own proof of concept.
  • Trust as a trigger is a new primitive. Every agent framework we studied uses static triggers — events, schedules, conditions. Making trust the trigger required rethinking how agents earn the right to act. We believe this is a contribution to how the industry thinks about agentic AI in organizations.
  • Trust × Role is a behavior matrix nobody else has built. Most agent frameworks have one mode. HPAT agents adapt on two axes simultaneously — how autonomous they are (trust) and how they relate to the human (role). An apprentice at Trust 3 gets coached. A CEO at Trust 0 gets strategic options. Same agent, same framework, 12 different behaviors.
  • Real-world validation. This isn't a theoretical framework. It emerged from 6 months of daily collaboration between a dental team and AI agents. The trust levels, the feedback loops, the personality layer — all of this was tested with real people doing real work before it was implemented on GitLab.
  • The soul.md concept. Giving an agent a defined personality, boundaries, and communication style changed how our team interacts with AI. They stopped saying "the bot" and started saying "Jarvis." That shift — from tool to teammate — is the entire point.

What we learned

The technical implementation is the easy part. The real challenge — in software development and in every industry — is integrating AI into human organizations.

People don't resist AI because it's bad. They resist it because they don't trust it. And trust isn't a feature you ship. It's something you earn, interaction by interaction, outcome by outcome.

GitLab's agent platform is uniquely positioned for this: issues are conversations, labels are state, merge requests are proof of work, and the entire history is auditable. It's not just a DevOps tool — it's a trust ledger.

What's next for HPAT Trust Framework — Agents That Earn Autonomy

  • Voice-first interface: Whisper STT integration so non-technical team members can interact with Jarvis by speaking, not typing
  • Multi-agent teams: Specialized agents for different practice domains (scheduling, inventory, compliance, HR) — each with independent trust scores
  • Cross-industry expansion: The trust framework isn't specific to dental practices. Any organization where humans and AI need to build working relationships can use HPAT — healthcare, legal, manufacturing, education
  • Self-improving workflows: Combining autoresearch capabilities with the feedback loop, so agents don't just learn from human feedback but proactively research better solutions

The vision: Every person in every organization gets their own Jarvis — an AI teammate that starts by observing, proves itself through outcomes, and gradually earns the autonomy to handle the tasks that humans shouldn't have to think about. Not because AI is better than humans. Because humans deserve to focus on what only humans can do.

Built With

  • agents.md
  • anthropic-claude
  • custom-agents
  • custom-flows
  • gitlab-duo-agent-platform
  • humanity
  • passion
  • soul.md
  • yaml
Share this project:

Updates