Ce Agent Native Architecture
Establish UI-to-agent tool parity so every user-facing action is callable by your coding agent in the same PR.
Overview
Agent-Native Architecture is a journey-wide agent skill that keeps every UI action mirrored by an agent tool—usable whenever a solo builder needs to prevent agent–app capability drift before committing features.
Install
npx skills add https://github.com/everyinc/compound-engineering-plugin --skill ce-agent-native-architectureWhat is this skill?
- Core rule: add the agent tool in the same PR when you add a UI feature
- Capability map table linking UI action, location, agent tool, and prompt reference
- Explains failure mode when agents cannot perform feed/library actions users can do in the app
- Ongoing practice integrated into development workflow—not a one-off audit
- Action parity principle for trust: agents should not ask what the product already supports
Adoption & trust: 1.5k installs on skills.sh; 20.5k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your app lets users do things in the UI that the agent cannot do, so requests fail with confusion instead of execution.
Who is it for?
Indie SaaS and agent-first products where the coding agent is a first-class user alongside the graphical UI.
Skip if: Static sites or CLIs with no agent surface where tool parity tables add no value.
When should I use this skill?
Adding or changing UI features in an agent-connected product; auditing whether agents can perform user-visible actions.
What do I get? / Deliverables
You maintain a capability map and ship UI features with matching tools and prompt references in the same PR.
- Capability map (UI action ↔ agent tool ↔ prompt reference)
- Agent tools added in parity with UI changes
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Draft a capability map while prototyping so the agent demo can call the same endpoints as mock UI buttons.
Add publish_to_feed alongside the Analysis view publish button in one PR.
When shipping Library → Add book UI, register add_book for the agent in the same change.
Reviewer checks the parity table row exists for each new UI action before merge.
After a UI rename, update tool names and system-prompt references so agents do not reference retired flows.
How it compares
Ongoing parity discipline for agent products—not a one-shot linter or generic REST code generator.
Common Questions / FAQ
Who is ce-agent-native-architecture for?
Solo builders and tiny teams shipping agent-connected apps who need agents to perform the same actions as the UI.
When should I use ce-agent-native-architecture?
During Build on every feature PR; during Validate when sketching agent surfaces; during Ship in review checklists; during Operate when UI changes risk leaving tools stale.
Is ce-agent-native-architecture safe to install?
Review the Security Audits panel on this page; the skill is process documentation—safety depends on how you implement the tools it asks you to add.
SKILL.md
READMESKILL.md - Ce Agent Native Architecture
<overview> A structured discipline for ensuring agents can do everything users can do. Every UI action should have an equivalent agent tool. This isn't a one-time check—it's an ongoing practice integrated into your development workflow. **Core principle:** When adding a UI feature, add the corresponding tool in the same PR. </overview> <why_parity> ## Why Action Parity Matters **The failure case:** ``` User: "Write something about Catherine the Great in my reading feed" Agent: "What system are you referring to? I'm not sure what reading feed means." ``` The user could publish to their feed through the UI. But the agent had no `publish_to_feed` tool. The fix was simple—add the tool. But the insight is profound: **Every action a user can take through the UI must have an equivalent tool the agent can call.** Without this parity: - Users ask agents to do things they can't do - Agents ask clarifying questions about features they should understand - The agent feels limited compared to direct app usage - Users lose trust in the agent's capabilities </why_parity> <capability_mapping> ## The Capability Map Maintain a structured map of UI actions to agent tools: | UI Action | UI Location | Agent Tool | System Prompt Reference | |-----------|-------------|------------|-------------------------| | View library | Library tab | `read_library` | "View books and highlights" | | Add book | Library → Add | `add_book` | "Add books to library" | | Publish insight | Analysis view | `publish_to_feed` | "Create insights for Feed tab" | | Start research | Book detail | `start_research` | "Research books via web search" | | Edit profile | Settings | `write_file(profile.md)` | "Update reading profile" | | Take screenshot | Camera | N/A (user action) | — | | Search web | Chat | `web_search` | "Search the internet" | **Update this table whenever adding features.** ### Template for Your App ```markdown # Capability Map - [Your App Name] | UI Action | UI Location | Agent Tool | System Prompt | Status | |-----------|-------------|------------|---------------|--------| | | | | | ⚠️ Missing | | | | | | ✅ Done | | | | | | 🚫 N/A | ``` Status meanings: - ✅ Done: Tool exists and is documented in system prompt - ⚠️ Missing: UI action exists but no agent equivalent - 🚫 N/A: User-only action (e.g., biometric auth, camera capture) </capability_mapping> <parity_workflow> ## The Action Parity Workflow ### When Adding a New Feature Before merging any PR that adds UI functionality: ``` 1. What action is this? → "User can publish an insight to their reading feed" 2. Does an agent tool exist for this? → Check tool definitions → If NO: Create the tool 3. Is it documented in the system prompt? → Check system prompt capabilities section → If NO: Add documentation 4. Is the context available? → Does agent know what "feed" means? → Does agent see available books? → If NO: Add to context injection 5. Update the capability map → Add row to tracking document ``` ### PR Checklist Add to your PR template: ```markdown ## Agent-Native Checklist - [ ] Every new UI action has a corresponding agent tool - [ ] System prompt updated to mention new capability - [ ] Agent has access to same data UI uses - [ ] Capability map updated - [ ] Tested with natural language request ``` </parity_workflow> <parity_audit> ## The Parity Audit Periodically audit your app for action parity gaps: ### Step 1: List All UI Actions Walk through every screen and list what users can do: ``` Library Screen: - View list of books - Search books - Filter by category - Add new book - Delete book - Open book detail Book Detail Screen: - View book info - Start research - View highlights - Add highlight - Share book - Remove from library Feed Screen: - View insights - Create new insight - Edit insight - Delete insight - Share insight Settings: - Edit profile - Change theme - Export data - Delete account ``` ### Step 2: Check Tool Coverage For each action,