01
Design
Define request-handling steps, inputs and outputs, shared rules, and transitions.
AI process management platform
Turn AI agent work into a manageable process
Design steps, define rules and data contracts, and connect external AI agents through MCP. Evolve the process with your team and evaluate outcomes by version and business KPI.
Graphs and shared rulesVersions and GitExternal agents through MCP
Process graph
Request handling
GraphRulesAgents
Accept request
intake-request
- Input
- request *
- Output
- request *
1RulesNext: Classify requestClassify request
classify-request
- Input
- request *
- Output
- category *
1RulesNext: Resolve requestResolve request
resolve-request
- Input
- category *
- Output
- response *
3RulesNext: Review responseReview response
review-result
- Input
- response *
- Output
- resolution_status *
2Rules
Resolve request · Instruction
Prepare a resolution. Return the response in the response field.
Rules
Response tone and fact checking
Agent context
Support specialist
Why AMS
Turn scattered prompts into a manageable process
When instructions, transitions, and data live in separate files, teams discover incompatible steps too late and lose sight of the process as a whole. AMS turns that environment into an explicit, versioned system.
One AMS workspace represents one agentic business process — from skill definitions to run history and business metrics.
Visible structure
Skills, allowed transitions, selection reasons, and missing targets are all shown on one graph.
Explicit contracts
Required and optional inputs and outputs are defined for every step.
Shared rules
Team requirements, commands, and non-secret constants are reused across steps without manual copying.
Observable execution
Related runs are grouped into process runs, providing the foundation for analytics and KPIs.
How it works
Design, run, measure, improve
Process definition and execution stay separate: AMS manages structure and history, while the model runs in an external agent environment.
02
Connect
Choose a version and connect an external AI agent through Remote MCP with the appropriate scopes.
03
Execute externally
The agent retrieves requested materials, executes skills in its own environment, and records the results.
04
Measure and improve
Compare versions, identify bottlenecks, and link skill outputs to business KPIs.
Use run outcomes to improve the next version
Features
Every process component in one workspace
From step structure to shared requirements and collaborative process improvement.
Structure
Define the process
Skill graph, transitions, and fallback paths
Contracts with typed inputs and required fields
Instructions and files for each step
Contract field suggestions without repeated entry
Rules
Set context and constraints
Shared rules for selected steps
Agent specialization and instructions for skills
Commands, constants, and MCP references through @ search
Limits on repeated skill runs
Evolution
Evolve it with your team
Editable versions and outcome comparisons
Roles, comments, and activity history
GitHub or GitLab for the primary version
Import, export, and recovery of deleted materials
Use @ search to insert commands, constants, and MCP references. Existing contract field suggestions reduce manual copying and repeated entry.
Define agent specialization and instructions for selected steps. Link them to shared process rules.
Versions and collaboration
Evolve the process without losing reproducibility
Teams can edit multiple versions in parallel. Each user independently selects a working version, while the primary version is used by default and synchronized with Git.
A new version includes skills, rules, agent definitions, element layout, and KPI mappings — without run history or comments.
The version, rules, and agent context are pinned at launch. Later edits do not switch a process already in progress.
An archived version remains available for history and comparison, but cannot accept changes or new runs.
Process versions
Request handling
v3 · Working
Primary versionUpdated
today, 2:32 PM
History
128 runs
OpenCompare
v4 · New fallback
In progressUpdated
today, 12:08 PM
History
7 runs
OpenCompare
v2 · Before optimization
ArchivedUpdated
July 28, 6:41 PM
History
94 runs
OpenRestore
Process is pinned
Changes to the primary version do not redirect a process that is already running.
Remote MCP and an open format
Connect an external agent to your process
AMS supplies instructions and pinned context. An external agent executes steps in its own environment and reports results, giving the team a process history.
- 01
Retrieve instructions and context
The contract, rules, and agent context from the pinned version.
- 02
Execute in the external environment
The agent uses its own model, tools, and security policies.
- 03
Report results
AMS validates required outputs and records transition decisions.
Two access modes
OAuth with PKCE or a personal API token.
Restricted permissions
User roles and connection scopes restrict operations.
Materials on request
The agent retrieves the materials it needs over Streamable HTTP Remote MCP.
Portable structure
Markdown + YAML.ams/
└─AMS.md
└─skills/
└─skill-name/SKILL.md
└─commands/
└─rules/
└─agents/
└─constants.json
Import an .ams.tar or .zip, export the workspace, and keep the primary version in Git. Rules and agent definitions are part of the portable process.
Analytics and KPIs
Measure the process, not isolated calls
Related runs are grouped into process runs, so statuses, transitions, errors, duration, bottlenecks, and business KPIs can be analyzed by version and initiator.
Example analytics · illustrative data
Process overview
Request handling
Last 30 daysCompare versions
Process runs
1,248
+12% this period
Success rate
94.8%
1,183 completed
p50 / p95
42s / 2.1m
across all versions
Bottleneck
review
38% of total time
Skill performance
Primary version · v3| Skill | Runs | Success | p50 |
|---|---|---|---|
| classify-request | 1,248 | 99% | 3.2s |
| resolve-request | 1,121 | 95% | 27.4s |
| review-result | 1,066 | 91% | 48.8s |
Business KPI
First-contact resolution
78.4%
Source: the `resolution_status` output of the `review-result` skill in v3.
If a skill or its output is missing from the selected version, AMS clearly marks the KPI as unavailable for that version.
Security
Clear access and execution boundaries
Your team controls the process definition and access. An external agent executes it in its own environment.
Roles and scopes
Team membership and roles are checked in the web interface and MCP. Connection scopes can only narrow permissions.
Pinned context
A run pins its selected version, rules, and instructions. Later edits do not change its context.
External execution environment
Models and scripts run in the external agent under its security policies.
Metadata without secrets
MCP references provide tool descriptions, not connection secrets or proxied access through AMS. The external agent uses its own connections.
Who it’s for
For teams bringing agents into real-world workflows
AMS gives business owners, engineers, and external agents a shared language — from process design to measurable outcomes.
Example processes
Feature delivery: analyze → implement → verify
Support: classify → resolve → escalate
Research with multiple continuation paths
Content: generate → review → approve
AI engineering teams
Align on steps and shared rules, discuss skills, and evaluate changes in separate versions.
Technical leaders
Define contracts, run limits, and fallback paths while controlling access and reproducibility.
Developers and integrators
Connect agents through MCP, synchronize with Git, and move processes between environments.
AI product owners
Connect technical runs to business KPIs and see where the process needs improvement.
Starter processes
Start with an example and adapt it to your team
Explore a ready-made structure, adapt its steps and rules to your needs, then connect an external agent.
Example processes
New accounts include six examples with graphs, branches, and illustrative analytics.
Community catalog
Explore published processes with skills, commands, rules, and agent context available to view.
Independent private copy
Copy a published process into your team and evolve it independently, without another team’s run history.
FAQ
Questions for technical evaluation
Looking for another detail? Request a demo and we’ll walk through the product using your scenario.
Hollon AMS is an AI process management platform. It brings together skill graphs, shared rules, data contracts, versions, collaboration, and analytics. External agents connect through MCP.
One workspace represents one agentic business process. It brings together shared rules, skills, data contracts, transitions, versions, permissions, and analytics.
In the current workflow, an external AI agent executes the process in its own environment. AMS supplies instructions and context through MCP, validates required results, and records execution history.
A built-in agent for launching processes from the AMS interface is in development and planned for future versions.
Through Remote MCP over Streamable HTTP. Interactive clients can use OAuth Authorization Code with PKCE, while headless scenarios can use personal API tokens. User roles and connection scopes restrict access.
A workspace can have several versions being edited in parallel. One is designated as primary and used by default; only that version synchronizes with GitHub or GitLab. A process already in progress stays on its selected version and captured definition state.
Yes. The portable part of a process uses an open Markdown + YAML structure. A workspace can be imported from TAR/ZIP, exported, duplicated, and stored in Git.
Telemetry is configured per connection. Extended mode may include arguments, MCP operation results, and trace events; this data is retained for no more than 30 days. AMS does not receive the model’s hidden reasoning.
Build your first manageable AI process
Start with an example or your own graph, define rules, and connect an external agent through MCP.