The Agentic Harness: Built-In Domain Agents for Your Generated App

When you generate an application with EcosystemCode, you get more than screens, APIs, and database tables. Every generated React and Vue application ships with a built-in Agentic Harness—an ontology-backed runtime that turns your UML diagrams, domain semantics, state machines, and sequence flows into action-capable domain agents inside your running app.

This tutorial explains what the agentic harness includes out of the box and how operators, architects, and administrators benefit from day one.

Specialists seeded from your model

A generic chatbot only knows what you paste into a prompt. The generated agentic harness starts with your application’s actual domain catalog (config/agents.json) and seeds five specialist agents tailored to your entities and workflows:

• Ecosystem Domain Orchestrator — plans multi-step work across entities, state machines, activity workflows, sequence playbooks, analytics, and runtime extensions.
• Entity CRUD & Triage Specialist — creates, inspects, and updates records using canonical lookup values and SHACL-compliant state transitions.
• Workflow & Sequence Playbook Runner — executes Activity Diagram workflows (config/workflows.json) and Sequence Diagram playbooks (config/sequences.json) step by step.
• Analytics & Executive Insights Agent — queries entity summaries, status distributions, and dashboard KPIs, then creates follow-up records when bottlenecks appear.
• Extensibility & Automation Architect — adds declarative business rules, event triggers, composite MCP macro tools, and custom specialist agents at runtime.

Each agent has a defined role, allowed tool categories, a default model tier, and ready-to-run sample prompts grounded in your domain entities.

Real actions through MCP tools

Every agent in the catalog acts through the generated Model Context Protocol (MCP) tool layer. When a user asks an agent to create a record, advance a lifecycle state, or run a playbook, the harness invokes the same validated services that power your REST API:

• CRUD and lifecycle tools for every generated entity and state machine.
• Sequence playbooks derived directly from your UML sequence diagrams in config/sequences.json.
• Activity workflows that track instance progress across nodes.
• Analytics and lookup tools that read live distributions and reference tables.

If a tool call fails validation, the harness receives a structured hint and self-corrects on the next step.

Kept honest by your ontology and SHACL shapes

Because the harness is generated alongside your domain ontology, every turn is grounded in config/ontology.json, config/ontology.ttl, and config/shapes.ttl:

1. Entity definitions and IRIs give agents unambiguous business meaning for every class and relationship.
2. SHACL constraints and required fields ensure records are created with valid attributes and legal state values.
3. Live category lookups supply canonical reference values so agents use your exact domain vocabulary.

Your diagrams and ontology define the rules once; the generated UI, backend APIs, and domain agents all honor the same contract.

Human-in-the-loop control and working memory

Putting agents on live operational data requires clear guardrails. The harness enforces a configurable execution policy across every session:

• confirm_destructive (default) — read and create operations run immediately, while destructive tool calls pause at an approval gate until the user confirms or rejects the action.
• plan_first — presents the proposed multi-step plan before running tools.
• autonomous — executes approved playbooks and multi-step workflows end to end.

As agents work, the Session Working Memory ledger records every entity created, updated, transitioned, inspected, or deleted, along with active workflow instances and a step-by-step tool execution trace with timings.

Multi-tier LLM routing—or run without an API key

Different tasks need different models. At /agent-settings, administrators configure provider credentials and map three task-complexity tiers—fast, standard, and reasoning—across:

• OpenAI (for example gpt-4o-mini and gpt-4o),
• Anthropic (for example Haiku, Sonnet, and Opus), or
• Local Ollama models discovered directly from your local runtime.

And if no external LLM API key is configured yet, the harness falls back to a deterministic MCP planner so teams can exercise tools, playbooks, and workflows immediately after starting the generated app.

Extend the running app without regenerating

When operational needs evolve, the Extensibility Agent and the workspace let teams extend the live application through configuration files (config/business-rules.json, config/custom-tools.json, and config/agents.json):

• Declarative business rules (beforeCreate, enrichment, validation) that run automatically in the service layer.
• Composite MCP macro tools that bundle frequent multi-step actions into a single reusable tool.
• Custom catalog agents with their own instructions, model tier, and permitted tool categories.

Where you use it in the generated app

Every generated application exposes the harness in two places:

1. The floating Agent Drawer — available on every screen so operators can ask questions, trigger actions, or approve pending steps without leaving their current view.
2. The full Agent Workspace (/agent) — a dedicated studio view with tabs for the Agent Catalog, live Tool Trace, Working Memory ledger, Sequence Playbooks, and Runtime Extensions.

How each role benefits

• Operators and business users complete multi-step data entry, triage, and status transitions in plain language while seeing every record touched in working memory.
• Software architects get an agent layer that is strictly bound to UML diagrams, state machines, and OWL/SHACL semantics through code generation.
• Administrators and platform teams control model cost tiers, local or cloud LLM providers, approval policies, and audit logs from /agent-settings.
• Delivery teams and evaluators can demo and test agentic workflows immediately on day one using the built-in deterministic planner, even before provisioning cloud LLM keys.

Next steps

• Learn how domain semantics power generation in Ontology-Driven Development.
• Explore what ships in every build on the Code Generation feature page.
• Try the product: open the workbench, or watch the demo for a guided tour.