01 · Agent lifecycle
Build or import
Start with a NEPOPSX workflow, compose a new agent, or import one already running in Claude Code or GitHub Copilot.
ResultCanonical agent + working unit
Owned by · Agent author
Create, discover, adapt, and govern agents across every team and workspace. NEPOPSX turns useful work into reviewed organizational knowledge, so agents improve with use instead of every developer teaching them the same things again.
NEPOPSX connects the work teams do locally with the agents, context, and controls the organization manages centrally — without forcing every repo into the same shape.
Compose ready-to-use agents or bring in what your teams already run, then make every approved unit discoverable.
Keep one canonical agent while each workspace adds its services, tools, conventions, and local policy.
Capture useful discoveries from real work, review them once, and recall only the knowledge relevant to the next task.
Control ownership, approvals, releases, rollout, audit history, and rollback as agents change across the organization.
One team can build the breakthrough. Every team can inherit it — adapted, reviewed, and still improving.
NEPOPSX manages two connected systems: how an agent becomes trusted organizational infrastructure, and how knowledge from real work safely improves what happens next.
Start with a NEPOPSX workflow, compose a new agent, or import one already running in Claude Code or GitHub Copilot.
Test behavior, scan the complete unit, assign ownership, and bless a traceable version for organizational use.
Find a proven agent in the organization catalog and install it with its skills, sub-agents, and handoffs intact.
Compile it against local services, tools, standards, and policy, then run it inside the team's existing coding tool.
Recall relevant approved knowledge before work, then propose useful discoveries after the task with source and scope attached.
Approve, edit, reject, or quarantine each proposal. Agent behavior changes become candidate versions, not silent rewrites.
Roll approved improvements out to the right workspaces, preserve the audit trail, and revert safely when needed.
Knowledge: approved practices become recallable on the next relevant task.
Behavior: structural changes return as a candidate version before rollout.
Start with complete, role-based workflows for spec-driven development, documentation, and QA. Customize their behavior and standards while your teams' own agents earn their place beside them.
From idea to shipped code — a pipeline of specialized sub-agents, each enforcing your team's approved standards as the work moves through it.
Takes a task from an agreed specification to verified code using the workspace's approved practices.
Outcome: less re-teaching, fewer unverified changes
Finds documentation drift, updates the right pages, and captures the decisions behind a change.
Outcome: documentation that stays trustworthy
Turns product intent into risk-based scenarios, executes them, and retains reusable quality knowledge.
Outcome: a repeatable team quality bar
Keep one canonical agent, then layer in each workspace's services, tools, conventions, enabled skills, and local policy. Teams customize their context without creating an untraceable fork.
Same blessed agent. Two workspaces. Native files for each.
Run the same command in the mobile repo and it renders against mobile's stack instead — no manual translation, no fork. No new editor, no new dashboard-first workflow: NEPOPSX lives inside each repo.
NEPOPSX comprehends agents already living in your repos, preserves their working relationships, and compiles them into a provider-neutral model that can be reviewed, adapted, and evolved without starting over.
Read Claude Code and GitHub Copilot agents directly from the repository.
Preserve orchestration, flag fidelity loss, dedupe against the catalog, and quarantine threats.
Bless the canonical agent, publish it to the org catalog, and render native provider files wherever it's installed.
Dry run is local, loss-aware, and safe to run in an existing repository.
nepopsx import-agents --dry-runAgents, skills, commands, and prompts are read from real repos, reviewed by a human, and published with ownership and origin attached. Teams discover proven work without losing accountability.
Blessing an orchestrator blesses its whole working unit — sub-agents and handoff targets travel together, so what you install is exactly what its authors run.
At task start, an agent queries the workspace's approved knowledge over MCP and pulls back only what's been reviewed. Not chat history — governed team knowledge.
Every learning and agent change has a source, scope, owner, and decision history. Security checks and confidence signals assist reviewers; people remain in control of what is released across the organization.
The same gate covers agents — nothing reaches the org catalog without a human blessing, and a quarantined member blocks its whole unit.
When checkout's install of debug-detective learns a better triage pattern, it's reviewed once — and every workspace running the agent picks it up on the next sync.
Payments ships an agent that works.
Mobile installs it, adapted to their stack.
Mobile's fixes flow back through review — and payments gets them too.
Approved learnings automatically flow back into every developer's agents.
The release manager one squad built becomes the release manager the whole company runs — reviewed, blessed, and improving with use.
Onboarding stops meaning "read the wiki." It means "start building, fully equipped."
Give teams room to adapt while leaders retain ownership, standards, release controls, and evidence of how every agent and learning changed over time.
Create. Adapt. Learn. Govern. Evolve.