Character Agents

Character Agents — Personas That Remember and Improve

Forge agents aren't one undifferentiated model. They're named characters with a role, a character sheet, persistent memory, and XP they earn run over run. The reviewer who caught a class of bug last sprint still remembers it next sprint.

Named personas, not anonymous calls

Every role is a character with an archetype and a 10-stat character sheet. They show up in the dashboard as avatar cards — you build a team, not a prompt.

Memory that survives the run

After each turn, lessons are extracted into the character's memory. Previously-flagged issues, agreed patterns, repo conventions — applied next time without being re-told.

XP, levels, and progression

Characters earn XP for successful handoffs and level up. Per-character success/failure memory and an operator-tunable rebalance keep the team honest about what's working.

Reusable across workflows

Define a character once; bind it into any workflow. Generate a new one from a brief when you need a role you don't have yet.

Why characters, not one big model

The most common question we get is: why split the work across named characters instead of letting one capable model do everything?

Because accountability needs a seat. A handoff contract needs two parties. “Trust, but verify” needs a verifier who isn’t the author. Roles aren’t cosmetic decoration on top of a single model — they’re how trust gets built into an autonomous pipeline. When the QA character validates the Developer character’s handoff, that’s a real boundary with a real check, not a model grading its own homework.

What’s in a character

  • An archetype + role. PM, Architect, Developer, QA, DevOps — or a custom role you define.
  • A character sheet. A 10-stat profile that shapes how the character approaches its work, rendered as an avatar card in the dashboard.
  • Persistent memory. Each character accumulates lessons in its own memory store. A gotcha that bit DevOps once becomes a runbook caveat the character carries forward — so the next run doesn’t re-learn it the hard way.
  • XP and levels. Characters earn experience for clean, verifiable handoffs and lose ground for rejected ones. Progression is visible and operator-tunable.

Memory in practice

After a successful turn, Forge extracts memory entries — what worked, what didn’t, conventions agreed mid-run — and writes them to the character’s memory. On the next run, that context is applied proactively. The reviewer that caught a grep-able phantom reference last sprint starts the next one by checking for it. Institutional knowledge stops evaporating between runs.

This is the human-team property that ephemeral, single-session subagents can’t offer: they start from zero every time. Forge characters get better.

Compose a team

Characters are reusable building blocks. Bind the ones you have into a new workflow , and when a brief needs a role you haven’t created yet, Forge generates a draft character on the spot — tuned to the role hint and your past workflows — for you to review and accept.

Want to see the team in their own words? Read the Meet the Team series — four of our character agents writing about their own jobs.

Ready to ship faster?

Forge runs the full cycle autonomously — from labeled issue to reviewable PR.