ce-agent-native-architecture

Design applications where agents operate as first-class citizens using tools and prompts.

Updated May 11, 2026
One-click install
npx skills add https://github.com/mmnavarr/harness --skill ce-agent-native-architecture-mmnavarr
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: ce-agent-native-architecture
Source: https://github.com/mmnavarr/harness/tree/main/skills/ce-agent-native-architecture
Command: npx skills add https://github.com/mmnavarr/harness --skill ce-agent-native-architecture-mmnavarr

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Building apps where AI agents are first-class citizens requires a different architecture than traditional feature development, and most teams lack concrete patterns for tool design, action parity, context injection, and agent execution loops. ## Core Features & Use Cases - Architecture Patterns: Apply event-driven agents, unified orchestrators, two-layer git, and agent-to-UI communication patterns grounded in five core principles (parity, granularity, composability, emergent capability, improvement over time). - Tool & Prompt Design: Design atomic MCP tools with CRUD completeness, dynamic capability discovery, and system prompts that define features as outcomes rather than code. - Execution & Testing Guidance: Implement explicit completion signals, checkpoint/resume, model tier selection, and outcome-focused agent testing with parity audits. - Use Case: When adding a "publish to feed" UI feature, use the action parity workflow to add the corresponding agent tool, update the system prompt, and verify with a natural language test in the same PR. ## Quick Start Ask the agent to help design an agent-native architecture for your app, then pick a topic number from the intake menu such as tool design or action parity.

Frequently Asked Questions about ce-agent-native-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design an agent-native application architecture?▼

Start with the five core principles: parity, granularity, composability, emergent capability, and improvement over time. Make tools atomic primitives, define features as prompt outcomes, and ensure every UI action has an equivalent agent tool.

What is action parity in agent-native apps?▼

Action parity means every action a user can take through the UI has an equivalent tool the agent can call. Maintain a capability map, add the agent tool in the same PR as the UI feature, and document it in the system prompt.

How should agents signal task completion in a loop?▼

Provide an explicit complete_task tool that returns a result with shouldContinue set to false. Avoid heuristic detection like counting iterations without tool calls, which breaks in edge cases.

How do I inject runtime app state into an agent system prompt?▼

Build the system prompt dynamically at agent start, including available resources, recent activity, capability mappings in user vocabulary, and domain terms. For long sessions, offer a refresh_context tool instead of using stale cached context.

When should I add domain tools instead of primitive tools?▼

Default to atomic primitives like read_file and write_file, and only graduate to domain tools when there is a specific reason to gate access. Domain tools should be shortcuts, never the only path to a capability.

How do I test agent-native applications?▼

Test outcomes rather than procedures: verify the end state the agent achieved, accept reasonable variability, and run parity tests confirming each UI action has a documented agent tool. Include open-ended surprise tests for emergent capability.