ce-agent-native-architecture

Design applications where agents achieve outcomes through atomic tools and prompt-defined features.

Updated Mar 17, 2026
One-click install
npx skills add https://github.com/Norfolk-Group/marcela-norfolk-ai --skill ce-agent-native-architecture-norfolk-group
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ce-agent-native-architecture
Source: https://github.com/Norfolk-Group/marcela-norfolk-ai/tree/main/skills/compound-engineering/skills/ce-agent-native-architecture
Command: npx skills add https://github.com/Norfolk-Group/marcela-norfolk-ai --skill ce-agent-native-architecture-norfolk-group

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Traditional software hardcodes features and workflows, leaving agents as thin wrappers that can only execute pre-built functions. This Skill guides you to build agent-native applications where agents operate in loops with atomic tools, achieving outcomes you describe in prompts rather than code you write. ## Core Features & Use Cases - Architecture Design: Apply five core principles (Parity, Granularity, Composability, Emergent Capability, Improvement Over Time) with a pre-implementation checklist covering tool design, workspace patterns, and context injection. - Tool & Prompt Design: Build atomic MCP primitives with full CRUD, dynamic capability discovery, explicit completion signals, and system prompts that inject runtime app state. - Testing & Refactoring: Run outcome-based capability tests, automated action-parity audits, and migrate existing code toward prompt-native behavior. - Use Case: When building a notes app, instead of writing a classify_and_organize_files function, you expose read_file, write_file, and move_file primitives plus a prompt describing the organization outcome, letting the agent handle edge cases with judgment. ## Quick Start Ask the agent to help design an agent-native architecture for your application and choose one of the thirteen intake topics such as tool design, action parity, or testing.

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 atomic primitive tools like read_file and write_file, define features as outcomes in the system prompt, and let the agent operate in a loop until it calls complete_task. Verify parity, granularity, composability, and emergent capability against the architecture checklist before implementation.

What is action parity in agent-native apps?

Action parity means every action a user can take through the UI has an equivalent agent tool. Maintain a capability map linking UI actions to tools, update it in every PR, and audit periodically to close gaps.

When should I add domain tools instead of primitives?

Add domain tools only as shortcuts for patterns users repeatedly request, never as gates that block primitive access. If a domain tool is the only way to do something without a specific reason, that is an anti-pattern.

How do agents signal task completion in a loop?

Provide an explicit complete_task tool whose result sets shouldContinue to false, stopping the loop. Avoid heuristic detection like counting iterations without tool calls, which breaks in edge cases.

How do I test an agent-native application?

Test outcomes rather than procedures: give the agent natural-language requests and verify the end state, run automated parity tests checking every UI action has a documented tool, and use open-ended surprise tests to confirm emergent capability.

What are common anti-patterns when building agent-native apps?

Common anti-patterns include workflow-shaped tools that bundle judgment into code, heuristic completion detection, incomplete CRUD, sandboxed agent workspaces, context starvation, and building the app first then bolting on an agent.