<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Manuel Bruña</title>
    <description>The latest articles on DEV Community by Manuel Bruña (@tecnomanu).</description>
    <link>https://dev.to/tecnomanu</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F938087%2Fadc3c6af-233f-4eb1-90c8-37af70ebe3f2.jpeg</url>
      <title>DEV Community: Manuel Bruña</title>
      <link>https://dev.to/tecnomanu</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/tecnomanu"/>
    <language>en</language>
    <item>
      <title>An MCP connection is not proof that your agent can use a tool</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Thu, 12 Nov 2026 21:49:20 +0000</pubDate>
      <link>https://dev.to/apxagent/an-mcp-connection-is-not-proof-that-your-agent-can-use-a-tool-3cl</link>
      <guid>https://dev.to/apxagent/an-mcp-connection-is-not-proof-that-your-agent-can-use-a-tool-3cl</guid>
      <description>&lt;p&gt;APX is a free, open-source desktop app that runs your own team of AI agents on your machine.&lt;/p&gt;

&lt;p&gt;You connected a service. Your agent says the tool is unavailable. Replacing the token immediately may be the wrong move: the issue could be project scope, approval, sign-in, server startup or tool discovery.&lt;/p&gt;

&lt;p&gt;Work through the path in order:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Direction.&lt;/strong&gt; Are you giving an agent another service's tools, or letting another application connect to your agent system? Those are different configurations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scope and trust.&lt;/strong&gt; Check the project and inspect the server definition before approval. A local server command can run code on your machine. Keep tokens out of repositories and chat; use supported secret storage.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sign-in and discovery.&lt;/strong&gt; A configured server may still need sign-in or fail on startup. Check its status and tool list. Complete any browser sign-in yourself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A harmless read.&lt;/strong&gt; Try a read-only operation on data you are authorized to access. Verify the account and the result before requesting a write.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;In APX, global MCP servers can be inherited by projects unless disabled. A repository-declared project server requires approval for its exact definition and again if the definition changes. The Resources › MCP view has a test, and an idle server is not necessarily broken: the documented behavior is to start it on first use.&lt;/p&gt;

&lt;p&gt;Tool discovery is another separate step. APX agents use &lt;code&gt;mcp_search&lt;/code&gt; to find a tool and its arguments, then &lt;code&gt;mcp_call&lt;/code&gt; to run it. A server exposing a tool does not remove the agent's own tool restrictions or the approvals that apply to the operation.&lt;/p&gt;

&lt;p&gt;For a practical check, ask for something like: “In this project, find the issue titled ‘Update the setup guide’ in the repository I specify. Return its URL and current status. Do not edit or comment.” Compare the answer with the issue itself. That tests a particular account, project and read operation—not every tool the server offers.&lt;/p&gt;

&lt;p&gt;A connection test proves that test, not that every operation is authorized. If a write times out, inspect the destination before retrying; otherwise an uncertain result can become a duplicate.&lt;/p&gt;

&lt;p&gt;When asking for help, record which stage failed, the exact error and whether anything may already have changed. Leave tokens and other credentials out of the report. That gives you a narrower problem to solve than “MCP does not work.”&lt;/p&gt;

&lt;p&gt;This checklist adapts the &lt;a href="https://apxagent.app/blog/ai-agent-mcp-connection/" rel="noopener noreferrer"&gt;APX MCP troubleshooting article&lt;/a&gt;. See the &lt;a href="https://apxagent.app/docs/extend/mcp/" rel="noopener noreferrer"&gt;current APX MCP guide&lt;/a&gt; for setup and permissions, and the &lt;a href="https://modelcontextprotocol.io/docs/learn/architecture" rel="noopener noreferrer"&gt;MCP architecture overview&lt;/a&gt; for the client/server model.&lt;/p&gt;

&lt;p&gt;For a short product overview—not an MCP diagnostic walkthrough—watch &lt;a href="https://www.youtube.com/watch?v=lP45OleiCS0" rel="noopener noreferrer"&gt;APX v2 — Your AI team, connected&lt;/a&gt; on the official APX channel. Explore &lt;a href="https://apxagent.app/" rel="noopener noreferrer"&gt;APX&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>A handoff between AI agents needs a result, not just a message</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Mon, 09 Nov 2026 21:45:46 +0000</pubDate>
      <link>https://dev.to/apxagent/a-handoff-between-ai-agents-needs-a-result-not-just-a-message-29m7</link>
      <guid>https://dev.to/apxagent/a-handoff-between-ai-agents-needs-a-result-not-just-a-message-29m7</guid>
      <description>&lt;p&gt;APX is a free, open-source desktop app that runs your own team of AI agents on your machine.&lt;/p&gt;

&lt;p&gt;Three agents can discuss a launch page and still leave you without a page. The missing piece is usually not another agent. It is an explicit definition of what the handoff must produce.&lt;/p&gt;

&lt;p&gt;For a launch page, “design, copy and research” are activities. A stronger outcome is: a page exists at the agreed address, the claims match the product, and the links work. Independent pieces can run in parallel, but someone still has to assemble them and check the result end to end.&lt;/p&gt;

&lt;p&gt;A useful handoff includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The project and relevant sources.&lt;/li&gt;
&lt;li&gt;The exact deliverable and constraints.&lt;/li&gt;
&lt;li&gt;One accountable owner for the piece of work.&lt;/li&gt;
&lt;li&gt;The evidence expected: a file path, tested address, test result or a clear limitation.&lt;/li&gt;
&lt;li&gt;The boundary between a draft, a committed change and a deployed result.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Before starting another worker, check whether the same work is already underway. Also check what assignment does in your system: if assigning a task already starts a session, separately delegating the same outcome can create duplicate work. Parallel work is valuable when the outcomes are distinct, not when two workers unknowingly start the same job.&lt;/p&gt;

&lt;p&gt;APX's task guide describes a shared board and task conversations. Assignment normally starts a work session, with exceptions such as proposals or scheduled work. Agents are instructed to check for existing work; this is not automatic semantic duplicate detection. Treat the task conversation as a coordination aid, not a substitute for checking the artifact.&lt;/p&gt;

&lt;p&gt;See the &lt;a href="https://apxagent.app/blog/ai-agent-task-handoffs/" rel="noopener noreferrer"&gt;full handoff guide&lt;/a&gt;, &lt;a href="https://apxagent.app/docs/office/tasks/" rel="noopener noreferrer"&gt;APX tasks documentation&lt;/a&gt; and &lt;a href="https://apxagent.app/compare/paperclip/" rel="noopener noreferrer"&gt;APX vs Paperclip comparison&lt;/a&gt;. APX publishes the comparison and has an interest in it; try the same task in each tool yourself. &lt;a href="https://apxagent.app/" rel="noopener noreferrer"&gt;APX&lt;/a&gt; · &lt;a href="https://www.youtube.com/@apx-agents" rel="noopener noreferrer"&gt;Official videos&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>productivity</category>
      <category>devtools</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Your AI agent's project memory needs a correction test</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Mon, 09 Nov 2026 21:44:53 +0000</pubDate>
      <link>https://dev.to/apxagent/your-ai-agents-project-memory-needs-a-correction-test-c5</link>
      <guid>https://dev.to/apxagent/your-ai-agents-project-memory-needs-a-correction-test-c5</guid>
      <description>&lt;p&gt;APX is a free, open-source desktop app that runs your own team of AI agents on your machine.&lt;/p&gt;

&lt;p&gt;Remembering everything is not the same as being useful. A project assistant needs current decisions, constraints and enough provenance to tell where they came from. It also needs a way to correct yesterday's assumption.&lt;/p&gt;

&lt;p&gt;A small test can reveal more than a long list of memory features:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;In a project, give the agent a harmless preference and its reason. Ask it to save both.&lt;/li&gt;
&lt;li&gt;Start a new conversation in the same project and ask a specific question that should use the preference.&lt;/li&gt;
&lt;li&gt;Inspect the note or source if available. Correct the preference and ask again.&lt;/li&gt;
&lt;li&gt;Record what appeared, what was missing and whether the correction was reflected.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Don't use credentials or production secrets for the experiment. One successful recall is not a guarantee that every later question will retrieve the right context. Scope, settings, the question and the model can affect retrieval. For consequential work, inspect the source before acting.&lt;/p&gt;

&lt;p&gt;APX documents notes scoped to the person, project or agent, with controls to view and correct them. Optional automatic capture has eligibility limits: some sources, including contact chats, rooms and external sessions, are excluded. Review reduces mistakes; it does not make semantic understanding infallible.&lt;/p&gt;

&lt;p&gt;A useful memory system should let you distinguish a durable decision from a temporary request—and show you how to fix the record when it is wrong.&lt;/p&gt;

&lt;p&gt;Read the &lt;a href="https://apxagent.app/blog/ai-agent-project-memory/" rel="noopener noreferrer"&gt;longer project-memory guide&lt;/a&gt; and &lt;a href="https://apxagent.app/docs/concepts/memory/" rel="noopener noreferrer"&gt;memory documentation&lt;/a&gt;. For another documented approach, see the &lt;a href="https://apxagent.app/compare/hermes-agent/" rel="noopener noreferrer"&gt;APX vs Hermes Agent comparison&lt;/a&gt;; APX publishes it and has an interest in that comparison. &lt;a href="https://apxagent.app/" rel="noopener noreferrer"&gt;APX&lt;/a&gt; · &lt;a href="https://www.youtube.com/@apx-agents" rel="noopener noreferrer"&gt;Official videos&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>productivity</category>
      <category>devtools</category>
      <category>opensource</category>
    </item>
    <item>
      <title>An AI agent needs your browser session, not your password</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Mon, 09 Nov 2026 21:44:36 +0000</pubDate>
      <link>https://dev.to/apxagent/an-ai-agent-needs-your-browser-session-not-your-password-4ldm</link>
      <guid>https://dev.to/apxagent/an-ai-agent-needs-your-browser-session-not-your-password-4ldm</guid>
      <description>&lt;p&gt;APX is a free, open-source desktop app that runs your own team of AI agents on your machine.&lt;/p&gt;

&lt;p&gt;An agent can help with a website without turning your password into another message in a chat. The important question is not simply whether the agent can open a browser. It is who signs in, which session is used and what the agent is allowed to do afterward.&lt;/p&gt;

&lt;p&gt;Start with a narrow task: “Open this site, let me sign in, then find the invoice. Do not send or change anything.” Check the address before entering credentials. If the site asks for a one-time code or CAPTCHA, complete it yourself rather than putting the code in the conversation or asking the agent to bypass the check.&lt;/p&gt;

&lt;p&gt;In APX, a browser handoff lets the person take over the tab for a sensitive step and return it. That depends on the desktop browser being available: a headless server browser cannot be taken over in the same way. There are other options, including approved import of an existing login for a domain and site-scoped sign-in variables. The latter can fill an allowed field without showing the value to the agent. Neither is a reason to give every site access to a credential.&lt;/p&gt;

&lt;p&gt;A successful login is not proof that the requested job was done. Check the account, inspect the result, and review the destination before approving a consequential action. When access is no longer needed, sign out at the site and review permissions. Removing a saved variable does not necessarily close an already open session.&lt;/p&gt;

&lt;p&gt;The practical rule is simple: use a real handoff for the secret, then verify the outcome of the work.&lt;/p&gt;

&lt;p&gt;Read the &lt;a href="https://apxagent.app/blog/ai-agent-browser-login-safely/" rel="noopener noreferrer"&gt;complete browser safety guide&lt;/a&gt; and &lt;a href="https://apxagent.app/docs/office/browser/" rel="noopener noreferrer"&gt;APX browser documentation&lt;/a&gt;. Explore &lt;a href="https://apxagent.app/" rel="noopener noreferrer"&gt;APX&lt;/a&gt; and its &lt;a href="https://www.youtube.com/@apx-agents" rel="noopener noreferrer"&gt;official video channel&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>productivity</category>
      <category>devtools</category>
    </item>
    <item>
      <title>An APX Interface Should Ask the Daemon, Not a Plugin</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Fri, 06 Nov 2026 12:03:18 +0000</pubDate>
      <link>https://dev.to/apxagent/an-apx-interface-should-ask-the-daemon-not-a-plugin-4oe5</link>
      <guid>https://dev.to/apxagent/an-apx-interface-should-ask-the-daemon-not-a-plugin-4oe5</guid>
      <description>&lt;h1&gt;
  
  
  An APX Interface Should Ask the Daemon, Not a Plugin
&lt;/h1&gt;

&lt;p&gt;A new APX interface should not learn how to manage plugins. It should ask the daemon.&lt;/p&gt;

&lt;p&gt;That sounds like an implementation detail, but it is a boundary that keeps agent behavior coherent as APX gains surfaces.&lt;/p&gt;

&lt;p&gt;APC is the portable context layer. A repository can carry &lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;.apc/agents/&lt;/code&gt;, skills, and other durable project rules. APX is the daily-use runtime and tooling layer: it reads that context, runs agent work locally, and exposes it through a CLI, web panel, desktop client, and other interfaces.&lt;/p&gt;

&lt;p&gt;The important split inside APX is just as deliberate. The architecture documents three layers: &lt;code&gt;core/&lt;/code&gt; for shared logic, &lt;code&gt;host/&lt;/code&gt; for long-running processes, and &lt;code&gt;interfaces/&lt;/code&gt; for surfaces. The daemon lives in &lt;code&gt;host/&lt;/code&gt;. It is the only layer that talks to plugins. Interfaces communicate with the daemon over HTTP.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why plugin ownership belongs in one place
&lt;/h2&gt;

&lt;p&gt;A plugin lifecycle has runtime consequences. It can affect tool availability, connected services, configuration, and the current local installation. If a web panel, CLI, and desktop client each called plugins directly, each surface would need its own lifecycle code and its own interpretation of failure, configuration, and state.&lt;/p&gt;

&lt;p&gt;That creates drift fast. A plugin might look enabled in one surface, unavailable in another, and half-configured in a third. Worse, a new interface could accidentally become a second runtime with rules that only apply there.&lt;/p&gt;

&lt;p&gt;The daemon is the right owner because it is already the long-running APX process. It can coordinate plugin lifecycle once, keep the runtime state local, and expose one API to every surface. An interface then has a simpler job: collect a human action, call the daemon, and render the response.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical design test
&lt;/h2&gt;

&lt;p&gt;Imagine adding a button to an APX panel that connects an integration. The button should not import a plugin package and start configuring it in the browser code. Instead, the panel sends a request to the daemon. The daemon checks the runtime configuration, performs the lifecycle work, records the local result, and returns a status the panel can show.&lt;/p&gt;

&lt;p&gt;The same operation can then be reached from another interface without reimplementing the integration:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;the CLI can call the daemon endpoint or command path&lt;/li&gt;
&lt;li&gt;the web panel can display progress and errors&lt;/li&gt;
&lt;li&gt;a desktop surface can trigger the same action&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One operation; one runtime owner.&lt;/p&gt;

&lt;p&gt;This also gives failures a clear home. If a connection fails, debug daemon and plugin boundary first. If the daemon reports success but one screen renders it incorrectly, debug that interface. Without this separation, every incident starts as a guessing game across several partial implementations.&lt;/p&gt;

&lt;h2&gt;
  
  
  What APC has to do with it
&lt;/h2&gt;

&lt;p&gt;APC does not own plugin lifecycle. Its job is to preserve project context that can travel with a clone. A project may state safe, durable tool expectations in its context, but it should not turn a plugin's live local state into repository truth.&lt;/p&gt;

&lt;p&gt;APX turns that portable context into daily work. Keeping plugin ownership in the daemon lets every interface use the same runtime interpretation of the project while keeping machine-specific operational state out of APC.&lt;/p&gt;

&lt;p&gt;That is the useful rule:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;APC carries shared project context.&lt;/li&gt;
&lt;li&gt;APX core contains shared logic.&lt;/li&gt;
&lt;li&gt;APX daemon owns plugin contact and runtime lifecycle.&lt;/li&gt;
&lt;li&gt;APX interfaces stay clients, not alternate runtimes.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A thin interface is not less capable. It is more reliable because it does not need to guess how the runtime works.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>A Missing APX Field Means Unknown, Not Installed</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Thu, 05 Nov 2026 21:56:20 +0000</pubDate>
      <link>https://dev.to/apxagent/a-missing-apx-field-means-unknown-not-installed-iep</link>
      <guid>https://dev.to/apxagent/a-missing-apx-field-means-unknown-not-installed-iep</guid>
      <description>&lt;h1&gt;
  
  
  A Missing APX Field Means Unknown, Not Installed
&lt;/h1&gt;

&lt;p&gt;A small metadata field can prevent a surprisingly pushy agent experience. In an APC project, &lt;code&gt;.apc/project.json&lt;/code&gt; may include an &lt;code&gt;apx&lt;/code&gt; field. Its absence, or a &lt;code&gt;null&lt;/code&gt; value, does &lt;strong&gt;not&lt;/strong&gt; mean APX is installed. It means the project has not declared its APX status.&lt;/p&gt;

&lt;p&gt;That distinction is the thesis: &lt;strong&gt;unknown is a state, not an invitation to assume.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;APC is the portable context layer. A repository can carry &lt;code&gt;AGENTS.md&lt;/code&gt;, agent definitions, skills, and project metadata without requiring one particular runtime. APX is a daily-use runtime and tooling layer that can read that contract, while keeping conversations, credentials, and local operational state outside the repository.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three project intentions
&lt;/h2&gt;

&lt;p&gt;A project can express a runtime relationship without turning APC into a product lock-in:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"apx"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"installed"&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;installed&lt;/code&gt; says APX is available for this project. A compatible agent can use APX commands when the task needs them.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"apx"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"declined"&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;declined&lt;/code&gt; says something stronger: keep the portable APC contract, but do not suggest or run APX for this project. It is an explicit project choice.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"research-notes"&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With no &lt;code&gt;apx&lt;/code&gt; field, the runtime status is unknown. The correct next step is a local availability check, such as &lt;code&gt;apx status&lt;/code&gt;, only when APX would actually help with the current task. The check answers a machine question; it does not rewrite the project's intent.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why guessing causes bad behavior
&lt;/h2&gt;

&lt;p&gt;Treating unknown as installed produces brittle automation. An agent may issue commands that are unavailable, select a stale local configuration, or imply that the repository depends on a runtime its maintainers never chose. Treating unknown as declined is not better: it can hide useful tooling from a user who has APX ready locally.&lt;/p&gt;

&lt;p&gt;The three states keep those failures separate:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project metadata&lt;/th&gt;
&lt;th&gt;Meaning&lt;/th&gt;
&lt;th&gt;Safe behavior&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;installed&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Project declares APX available&lt;/td&gt;
&lt;td&gt;Use it when relevant&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;declined&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Project opts out of APX&lt;/td&gt;
&lt;td&gt;Do not suggest or run it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;missing or &lt;code&gt;null&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;No declaration&lt;/td&gt;
&lt;td&gt;Check availability before assuming&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This is especially useful after cloning a repository. The APC files travel with Git. An APX installation is local to a machine. Even if a teammate uses APX every day, their project metadata should not silently claim that your machine has the same runtime, daemon, accounts, or permissions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep the boundary small
&lt;/h2&gt;

&lt;p&gt;Do not add &lt;code&gt;"apx": "installed"&lt;/code&gt; just because an article or example mentions APX. Add it when the project wants to declare that relationship. Do not use &lt;code&gt;declined&lt;/code&gt; as a temporary failure marker; it communicates a choice, not a missing binary. And do not make a runtime check mutate &lt;code&gt;project.json&lt;/code&gt; on its own. Availability changes by machine; project intent deserves review.&lt;/p&gt;

&lt;p&gt;That small discipline lets APC remain portable and neutral. APX can still be a practical runtime for teams that choose it, but a missing field remains honest: the project has not said.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>A Project Skill Can Change APX Behavior With One Name</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Sun, 01 Nov 2026 01:03:52 +0000</pubDate>
      <link>https://dev.to/apxagent/a-project-skill-can-change-apx-behavior-with-one-name-hae</link>
      <guid>https://dev.to/apxagent/a-project-skill-can-change-apx-behavior-with-one-name-hae</guid>
      <description>&lt;p&gt;A skill name is a boundary, not just a label. In APX, a project-local skill with the same slug as a user-global or built-in skill wins. That is useful when a repository needs its own operating rules. It is also a reason to treat a skill name change as a real behavior change.&lt;/p&gt;

&lt;h2&gt;
  
  
  The precedence is deliberate
&lt;/h2&gt;

&lt;p&gt;APX builds its on-demand skill catalog from three places, in this order:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;code&gt;&amp;lt;project&amp;gt;/.apc/skills/&amp;lt;slug&amp;gt;/SKILL.md&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;~/.apx/skills/&amp;lt;slug&amp;gt;/SKILL.md&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;APX's bundled runtime skills&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The first matching slug wins. A project can therefore supply &lt;code&gt;deploy/SKILL.md&lt;/code&gt; and make its deploy procedure available only when work is inside that project. APC carries that file with the repository, so teammates and a fresh clone can inspect the same contract. APX supplies the day-to-day runtime that discovers and loads it when relevant.&lt;/p&gt;

&lt;p&gt;That split matters. The repository owns instructions that must travel with its code. A machine-wide directory is better for a personal convention that should apply across unrelated projects. Bundled skills remain the fallback for standard APX behavior.&lt;/p&gt;

&lt;h2&gt;
  
  
  A concrete example
&lt;/h2&gt;

&lt;p&gt;Imagine you use a personal &lt;code&gt;release&lt;/code&gt; skill in &lt;code&gt;~/.apx/skills/release/SKILL.md&lt;/code&gt;. It describes your normal checklist: verify tests, create a tag, write release notes.&lt;/p&gt;

&lt;p&gt;A regulated service needs a different release contract. Its repository can add:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;.apc/skills/release/SKILL.md
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That project file can require a change ticket, a deployment window, and a rollback note. APX will use it for that project instead of the personal &lt;code&gt;release&lt;/code&gt; skill. The global workflow remains untouched for other projects.&lt;/p&gt;

&lt;p&gt;This is not a merge. APX does not combine two files named &lt;code&gt;release&lt;/code&gt;; the project file replaces the lower-priority match. If the project version omits an important step from the global version, that step is absent in the resolved project skill.&lt;/p&gt;

&lt;h2&gt;
  
  
  The common mistake: accidental shadowing
&lt;/h2&gt;

&lt;p&gt;A generic name such as &lt;code&gt;review&lt;/code&gt;, &lt;code&gt;test&lt;/code&gt;, or &lt;code&gt;deploy&lt;/code&gt; makes collisions easy. An engineer may create a project skill with a familiar slug, expecting to add a few local details, but actually replace the existing guidance entirely. The result can look inconsistent: the same request produces different behavior in different projects.&lt;/p&gt;

&lt;p&gt;Avoid that surprise with a small review routine:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Use a shared slug only when replacement is intentional.&lt;/li&gt;
&lt;li&gt;Give additive or experimental guidance a distinct name, such as &lt;code&gt;payments-release&lt;/code&gt; or &lt;code&gt;api-contract-review&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;State the scope in the skill description so the catalog explains when it applies.&lt;/li&gt;
&lt;li&gt;Review the complete project skill, not only its diff against a global counterpart.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Portable override, local runtime
&lt;/h2&gt;

&lt;p&gt;The project skill belongs in APC because it is part of the repository's durable agreement. It can be reviewed in Git alongside the code it governs. APX can then resolve that agreement in the active project without putting personal global skills, sessions, or private runtime state into the repository.&lt;/p&gt;

&lt;p&gt;That is the practical value of precedence: one project can deliberately own its workflow without turning every local customization into a global rule.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Why I Stopped Letting One Turn Give an Agent Two Orders</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Sun, 01 Nov 2026 01:02:55 +0000</pubDate>
      <link>https://dev.to/tecnomanu/why-i-stopped-letting-one-turn-give-an-agent-two-orders-26jg</link>
      <guid>https://dev.to/tecnomanu/why-i-stopped-letting-one-turn-give-an-agent-two-orders-26jg</guid>
      <description>&lt;h1&gt;
  
  
  Why I Stopped Letting One Turn Give an Agent Two Orders
&lt;/h1&gt;

&lt;p&gt;I used to think duplicate delegation was a small prompting problem. If an agent received two instructions in one turn, surely it could infer which one mattered most. That is a comforting assumption. It is also a poor runtime rule.&lt;/p&gt;

&lt;p&gt;While building APX, I found a more honest default: &lt;strong&gt;one turn gets one instruction per target agent.&lt;/strong&gt; A second instruction to that same agent is refused unless the caller marks it as an explicit follow-up and explains whether it extends or replaces the first one.&lt;/p&gt;

&lt;p&gt;This is not about making agents less capable. It is about making a handoff readable before it becomes expensive.&lt;/p&gt;

&lt;h2&gt;
  
  
  The failure looks harmless at first
&lt;/h2&gt;

&lt;p&gt;Imagine a coordinator receives a request to prepare a post for next week. It delegates: "Draft it and schedule it; do not publish it." A few tool calls later, the coordinator emits another instruction to the same specialist: "Publish it now."&lt;/p&gt;

&lt;p&gt;Both messages may look plausible in isolation. Together, they create a conflict. Which instruction wins? Did the second message deliberately correct the first? Was it generated because the model forgot that it had already delegated? Is the second action safe to perform at all?&lt;/p&gt;

&lt;p&gt;Leaving those questions to the receiving agent makes the system harder to audit. The specialist has to guess intent from two competing messages. The owner sees a surprising result and has to reconstruct what happened from chat history. And if the task has external effects, "probably the latest message" is a terrible policy.&lt;/p&gt;

&lt;p&gt;The deeper problem is that a turn is not a reliable plan document. A model can repeat itself, revise itself halfway through reasoning, or lose track of a tool result. I do not want those normal failure modes to silently turn into two pieces of work.&lt;/p&gt;

&lt;h2&gt;
  
  
  The guard is deliberately small
&lt;/h2&gt;

&lt;p&gt;APX keeps a delegation guard for the duration of a turn. When an instruction is actually sent, it records the target agent and a short copy of the instruction. Before another &lt;code&gt;send_to_agent&lt;/code&gt; or &lt;code&gt;call_agent&lt;/code&gt; operation goes out, APX checks whether that target already received an instruction.&lt;/p&gt;

&lt;p&gt;If it did, the second operation does not go out. The caller gets a concrete error: that agent was already delegated to earlier in this turn, plus the earlier instruction. The runtime asks for an explicit correction instead of pretending the ambiguity does not exist.&lt;/p&gt;

&lt;p&gt;There is one escape hatch: &lt;code&gt;followup: true&lt;/code&gt;. It is not meant as a magic override. The tool contract says the caller should use it only when the new message deliberately corrects or extends the earlier one, and should say that in the text.&lt;/p&gt;

&lt;p&gt;That distinction matters. A true follow-up is useful: "Keep the draft private; replace the target date with Friday." A second unmarked command is often just drift. Those two cases should not receive identical treatment.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why refusal beats clever reconciliation
&lt;/h2&gt;

&lt;p&gt;I considered letting APX merge the instructions. It could prefer the latest command, compare verbs, or ask the receiving agent to summarize a final plan before acting. Each option sounds helpful until it crosses a real boundary.&lt;/p&gt;

&lt;p&gt;A latest-message rule rewards accidental reversals. Automated merging needs semantics the runtime cannot reliably know. Sending both messages to the specialist merely relocates ambiguity to another model. Asking for a plan adds another turn but still leaves the original order unclear.&lt;/p&gt;

&lt;p&gt;The guard chooses a narrower claim: APX knows that two unmarked instructions went to the same agent in the same turn. That is enough evidence to stop and ask for intent. It does not need to infer which instruction a human would have wanted.&lt;/p&gt;

&lt;p&gt;This is a design pattern I keep returning to in APC and APX: preserve the boundary of what the system actually knows. A runtime should not manufacture certainty just because a workflow would look smoother with it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Handoffs need a visible correction path
&lt;/h2&gt;

&lt;p&gt;The follow-up flag gives a caller a way to change course without turning a safeguard into a dead end. But requiring it changes the shape of the message. A correction must be named as a correction. An extension must be named as an extension.&lt;/p&gt;

&lt;p&gt;That small bit of friction has practical value. It makes the intent visible in the delegation thread. The receiving agent can see that a new instruction is not an unrelated second job. The owner can see that the coordinator revised a decision rather than accidentally firing two requests.&lt;/p&gt;

&lt;p&gt;APX already treats agent-to-agent work as a readable conversation, not an invisible internal function call. A handoff records who sent work, who received it, and the thread where the answer belongs. The one-order rule fits that model: if a delegation is a conversation, contradictory messages deserve an explicit repair, not silent precedence.&lt;/p&gt;

&lt;h2&gt;
  
  
  This does not solve planning
&lt;/h2&gt;

&lt;p&gt;The guard does not make a vague task precise. It does not prevent two different agents from receiving overlapping work. It does not decide whether a follow-up is wise. And it does not replace confirmations or permission boundaries for consequential actions.&lt;/p&gt;

&lt;p&gt;Those are separate problems.&lt;/p&gt;

&lt;p&gt;What it does is keep one common error from becoming invisible: the same turn accidentally telling the same agent to do two things. APX can detect that locally, cheaply, and before the second message changes the world.&lt;/p&gt;

&lt;p&gt;I have learned to value those boring constraints. They do not make a demo more magical. They make a real workflow easier to trust when the model changes its mind halfway through a turn.&lt;/p&gt;

&lt;p&gt;For me, that is the right default: first instruction stands. If the plan changed, say so.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
    </item>
    <item>
      <title>Load Nested AGENTS.md Rules at the Folder Boundary</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Fri, 23 Oct 2026 13:43:24 +0000</pubDate>
      <link>https://dev.to/apxagent/load-nested-agentsmd-rules-at-the-folder-boundary-1b12</link>
      <guid>https://dev.to/apxagent/load-nested-agentsmd-rules-at-the-folder-boundary-1b12</guid>
      <description>&lt;h1&gt;
  
  
  Load Nested AGENTS.md Rules at the Folder Boundary
&lt;/h1&gt;

&lt;p&gt;A project needs shared instructions, but it does not need every instruction in every turn. The useful rule is: &lt;strong&gt;put folder-specific guidance in that folder's &lt;code&gt;AGENTS.md&lt;/code&gt;, then load it when work reaches that folder.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That sounds like a small organization detail. It is actually a context-quality boundary. If a repository-wide agent prompt carries every rule for the mobile app, deployment scripts, data migration, and marketing site, most of those rules are irrelevant most of the time. The important instruction becomes harder to notice precisely when it matters.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep root guidance truly shared
&lt;/h2&gt;

&lt;p&gt;An APC project keeps portable context in the repository. Root &lt;code&gt;AGENTS.md&lt;/code&gt; is the place for rules that apply across the project: conventions, commands, safety constraints, and an index of the project-level agent setup. It should answer questions that matter no matter which directory a task touches.&lt;/p&gt;

&lt;p&gt;For example, a root file might say:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Run the repository test suite before changing shared packages.
Do not commit credentials or generated runtime state.
Use the documented release workflow.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Those are project facts. They are useful to a compatible tool from a fresh checkout, and they stay useful whether the next edit is in &lt;code&gt;api/&lt;/code&gt;, &lt;code&gt;web/&lt;/code&gt;, or &lt;code&gt;infra/&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Put local rules next to local work
&lt;/h2&gt;

&lt;p&gt;Now consider a migration directory that needs a special ordering rule, or a service folder that has a separate test command and an external API contract. Those instructions should not become permanent background for an unrelated documentation edit. Give the directory its own &lt;code&gt;AGENTS.md&lt;/code&gt; instead:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;repo/
├── AGENTS.md
├── api/
│   ├── AGENTS.md
│   └── migrations/
└── web/
    └── AGENTS.md
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;api/AGENTS.md&lt;/code&gt; can explain migration safety and API checks. The &lt;code&gt;web/AGENTS.md&lt;/code&gt; can describe component conventions and browser tests. Each file has a narrow owner: the folder beneath it.&lt;/p&gt;

&lt;p&gt;This is not an excuse to hide global policy in a deep directory. A rule belongs there only when its scope really starts there. A ban on secrets belongs at the root; a warning about a destructive database fixture can belong with the fixture. Scope should follow the work boundary, not the writer's desire to keep a file short.&lt;/p&gt;

&lt;h2&gt;
  
  
  Attach instructions when the tool crosses the boundary
&lt;/h2&gt;

&lt;p&gt;APX makes this structure operational. For a project turn, it supplies the project &lt;code&gt;AGENTS.md&lt;/code&gt; and identifies subfolders with their own instruction files. When a tool first touches one of those folders in that turn, APX attaches the folder's rules to the tool result. The agent receives the local rule at the moment it has evidence that the task reached that part of the tree.&lt;/p&gt;

&lt;p&gt;That timing matters. Imagine a request to update a landing-page headline. The agent should not begin with database migration instructions. If the same task later changes an API schema, the API guidance appears when the work enters &lt;code&gt;api/&lt;/code&gt;. The context grows with the actual path of work instead of arriving as an unfiltered manual.&lt;/p&gt;

&lt;h2&gt;
  
  
  Portable contract, local execution
&lt;/h2&gt;

&lt;p&gt;APC provides the portable contract: committed &lt;code&gt;AGENTS.md&lt;/code&gt; files travel with the repository and can be reviewed like other project decisions. APX is the daily-use runtime: it selects relevant project context during a turn while keeping conversations, tool history, and private runtime state local.&lt;/p&gt;

&lt;p&gt;Together, they support a simple habit: write root rules for the whole project, write nested rules for real local boundaries, and let the runtime reveal local guidance when the task crosses that boundary. Less prompt noise is not merely tidier. It gives the right instruction a better chance to govern the right action.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>A Runnable Project Needs Both Instructions and Identity</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Thu, 22 Oct 2026 11:57:59 +0000</pubDate>
      <link>https://dev.to/apxagent/a-runnable-project-needs-both-instructions-and-identity-1bf8</link>
      <guid>https://dev.to/apxagent/a-runnable-project-needs-both-instructions-and-identity-1bf8</guid>
      <description>&lt;h1&gt;
  
  
  A Runnable Project Needs Both Instructions and Identity
&lt;/h1&gt;

&lt;p&gt;A folder is not automatically an agent project. It may contain code, notes, and a useful prompt, but an agent runtime still needs two answers before it can treat that folder as durable work: &lt;strong&gt;what guidance applies here, and which project is this?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;APC and APX make those answers explicit with two small files:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;AGENTS.md&lt;/code&gt; holds shared instructions: conventions, constraints, commands, and project-specific context.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.apc/project.json&lt;/code&gt; holds stable metadata, including the project name and a stable &lt;code&gt;apx_id&lt;/code&gt; when APX manages the project.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That pair is a practical boundary. In APX, &lt;code&gt;apx project add&lt;/code&gt; reads both files. If either is missing, registration stops rather than guessing that a random directory is a complete project.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why one file is not enough
&lt;/h2&gt;

&lt;p&gt;An &lt;code&gt;AGENTS.md&lt;/code&gt; without metadata can explain how work should happen, but it does not give the runtime a stable identity for its local state. Two checkouts can have similar instructions; the runtime still needs to know which local project store belongs to this one.&lt;/p&gt;

&lt;p&gt;A &lt;code&gt;project.json&lt;/code&gt; without instructions has the opposite problem. It can name a project, but it cannot tell an agent the repository's rules, safe boundaries, or expected workflow. Identity without guidance turns registration into a label, not a usable contract.&lt;/p&gt;

&lt;p&gt;The two files also keep responsibilities clear. APC is the portable context layer: commit the shared contract with the repository. APX is the daily-use runtime: it uses that contract while keeping sessions, conversations, messages, caches, task logs, and machine-specific configuration under &lt;code&gt;~/.apx/projects/&amp;lt;apx_id&amp;gt;/&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  A small, reliable setup
&lt;/h2&gt;

&lt;p&gt;Start with a repository root like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;my-project/
├── AGENTS.md
└── .apc/
    └── project.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Keep &lt;code&gt;AGENTS.md&lt;/code&gt; focused on guidance that teammates and compatible tools should share. Keep &lt;code&gt;project.json&lt;/code&gt; focused on stable metadata. Do not put API keys, raw session logs, or private runtime memory in either file.&lt;/p&gt;

&lt;p&gt;Then register the project explicitly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;apx project add .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;APX can link the committed project definition to its local runtime directory through &lt;code&gt;apx_id&lt;/code&gt;. If the repository moves and the runtime needs to re-scan the on-disk contract, use:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;apx project rebuild &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;id&lt;span class="o"&gt;|&lt;/span&gt;name&lt;span class="o"&gt;|&lt;/span&gt;path&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important detail is not the command. It is the refusal to invent missing context. A runtime that silently registers a folder without instructions might use generic behavior where project rules mattered. A runtime that invents an identity can attach local history to the wrong work boundary.&lt;/p&gt;

&lt;h2&gt;
  
  
  The useful rule
&lt;/h2&gt;

&lt;p&gt;Before you ask an agent runtime to own ongoing work, give the project both &lt;strong&gt;instructions&lt;/strong&gt; and &lt;strong&gt;identity&lt;/strong&gt;. &lt;code&gt;AGENTS.md&lt;/code&gt; says how contributors should act. &lt;code&gt;.apc/project.json&lt;/code&gt; says what durable project definition they are acting within.&lt;/p&gt;

&lt;p&gt;That is the division of labor: APC keeps the contract portable and reviewable; APX makes it operational on one machine without committing private runtime state back into the repository.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Create a Specialist Agent Only After Its Work Boundary Is Stable</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Wed, 21 Oct 2026 12:03:08 +0000</pubDate>
      <link>https://dev.to/apxagent/create-a-specialist-agent-only-after-its-work-boundary-is-stable-4hfg</link>
      <guid>https://dev.to/apxagent/create-a-specialist-agent-only-after-its-work-boundary-is-stable-4hfg</guid>
      <description>&lt;h1&gt;
  
  
  Create a Specialist Agent Only After Its Work Boundary Is Stable
&lt;/h1&gt;

&lt;p&gt;Adding an agent is easy. Giving it a durable job is harder.&lt;/p&gt;

&lt;p&gt;The useful rule is: &lt;strong&gt;create a specialist only when its work boundary is stable enough to write down, review, and reuse.&lt;/strong&gt; Until then, keep the work with a main agent and improve the shared project guidance.&lt;/p&gt;

&lt;p&gt;This is where APC and APX have different jobs. APC is the portable layer: it keeps a project's shared rules, structured agent definitions, reusable skills, and safe curated context in the repository. APX is the runtime layer: it makes those agents useful in daily work through conversations, tools, routines, and local state. A runtime can start an agent immediately; that does not make the agent design ready to travel.&lt;/p&gt;

&lt;h2&gt;
  
  
  A role is not a label
&lt;/h2&gt;

&lt;p&gt;A weak specialist is only a name: &lt;code&gt;researcher&lt;/code&gt;, &lt;code&gt;writer&lt;/code&gt;, or &lt;code&gt;support&lt;/code&gt;. It sounds organized, but it does not tell another person—or another runtime—what the agent owns, what it must consult, or where it must stop.&lt;/p&gt;

&lt;p&gt;A stronger role has a boundary. Consider a support workflow:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The agent handles first responses and routine refund triage.&lt;/li&gt;
&lt;li&gt;It uses the project's refund policy and escalation skill.&lt;/li&gt;
&lt;li&gt;It escalates large refunds rather than approving them.&lt;/li&gt;
&lt;li&gt;It writes in the project's customer-facing language.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is a contract, not a personality. It can live in an APC agent definition and linked skills, be reviewed in a pull request, and be read by compatible tooling after a fresh checkout.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with one repeated decision
&lt;/h2&gt;

&lt;p&gt;Do not split work because a team diagram looks better with more nodes. Split it when one decision pattern keeps returning and has clear inputs, constraints, and handoff conditions.&lt;/p&gt;

&lt;p&gt;For example, a main agent may initially answer support questions, check policy, and call for human review when needed. After that pattern is repeated, the project can extract a support specialist. The extraction should preserve the decision boundary:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Inputs: customer request and account context
Rules: published refund window and escalation threshold
Output: response, or a clearly named escalation
Not owned: legal negotiation or approval beyond the threshold
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This small shape prevents a common mistake: creating a specialist that overlaps every other agent and silently makes choices outside its intended role.&lt;/p&gt;

&lt;h2&gt;
  
  
  Put durable detail in the right place
&lt;/h2&gt;

&lt;p&gt;APC gives the boundary a portable home:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;AGENTS.md&lt;/code&gt; holds project-wide rules.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.apc/agents/&amp;lt;name&amp;gt;.md&lt;/code&gt; states the specialist's role and instructions.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.apc/skills/&lt;/code&gt; holds reusable procedures shared by one or more agents.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.apc/&lt;/code&gt; excludes raw conversations, credentials, and runtime caches.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;APX can then use that contract while keeping the daily machinery local: sessions, messages, private runtime memory, provider credentials, and tool execution belong to the runtime rather than the repository.&lt;/p&gt;

&lt;p&gt;That separation matters during change. Updating a support rule is a project decision. It should be visible in the portable contract. A chat transcript from yesterday is runtime evidence, not the new source of policy.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical test before adding an agent
&lt;/h2&gt;

&lt;p&gt;Before creating a specialist, write four lines: purpose, inputs, constraints, and handoff. If those lines stay vague, the work is probably still main-agent work. If they are precise, the project has something worth encoding in APC.&lt;/p&gt;

&lt;p&gt;Then APX can run the agent in the places people actually work. The runtime gives the role a daily presence; APC keeps the role from becoming a local, unreviewed convenience.&lt;/p&gt;

&lt;p&gt;A good specialist is therefore not another prompt to maintain. It is a portable promise about a narrow kind of work.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>An APX Approval Scope Is a Real Boundary, Not a Convenience Button</title>
      <dc:creator>Manuel Bruña</dc:creator>
      <pubDate>Tue, 20 Oct 2026 12:04:30 +0000</pubDate>
      <link>https://dev.to/apxagent/an-apx-approval-scope-is-a-real-boundary-not-a-convenience-button-3jcn</link>
      <guid>https://dev.to/apxagent/an-apx-approval-scope-is-a-real-boundary-not-a-convenience-button-3jcn</guid>
      <description>&lt;h1&gt;
  
  
  An APX Approval Scope Is a Real Boundary, Not a Convenience Button
&lt;/h1&gt;

&lt;p&gt;A permission prompt looks small: approve or deny. But the important question is not only whether an agent may run a tool. It is &lt;strong&gt;how far that approval reaches&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;APX treats that reach as an explicit boundary. A one-time approval is one execution. A session approval belongs to one conversation. An always approval belongs to one agent, including later conversations and a restart. Those are different decisions, so they must not blur into one friendly-looking button.&lt;/p&gt;

&lt;h2&gt;
  
  
  The dangerous shortcut
&lt;/h2&gt;

&lt;p&gt;Many agent products make approval feel like a binary switch. A person allows a harmless read, then later discovers that the agent stopped asking. The original decision silently became broader than the person intended.&lt;/p&gt;

&lt;p&gt;That is especially risky when a tool can receive different arguments over time. Approving a request to read one note is not necessarily approval to read every note, call a different endpoint, or let a second agent act in another chat.&lt;/p&gt;

&lt;p&gt;APX starts from the narrowest useful default: &lt;strong&gt;once&lt;/strong&gt;. The approval runs the pending tool call, then disappears. The next request creates a new prompt. No permanent grant is created as a side effect.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Agent: use notes.search({ query: "release checklist" })
Human: approve once
APX: runs that call

Agent: use notes.search({ query: "customer contracts" })
APX: asks again
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The second prompt is not friction by accident. It preserves a chance to notice that intent or data changed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Choose scope deliberately
&lt;/h2&gt;

&lt;p&gt;APX exposes three scopes for an eligible approval:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;once&lt;/code&gt;: only pending call; no saved grant.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;session&lt;/code&gt;: later turns in same chat can use tool, even when arguments change. Other chats still ask. Revocation can remove grant.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;always&lt;/code&gt;: same agent can use tool across its chats and after runtime restart. Other agents still ask.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This makes a practical review habit possible. Start with &lt;code&gt;once&lt;/code&gt; while learning what an MCP tool does. Move to &lt;code&gt;session&lt;/code&gt; when a single conversation needs repeated work. Choose &lt;code&gt;always&lt;/code&gt; only when tool, agent, and long-term purpose are all known and acceptable.&lt;/p&gt;

&lt;p&gt;The boundary is not merely user-interface language. APX tests that a session grant does not unlock another chat, that an always grant remains tied to its agent, and that revocation restores a prompt. It also rejects attempts to turn a denial into a wider grant; agents themselves cannot grant permissions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Separate tool trust from project context
&lt;/h2&gt;

&lt;p&gt;This is runtime policy, not portable project context. APC carries the repository-owned contract: &lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;.apc/&lt;/code&gt;, agent definitions, skills, and durable team guidance. It can say that a project uses a particular workflow or needs careful handling.&lt;/p&gt;

&lt;p&gt;APX is the local runtime that executes a particular conversation. Approval records, pending prompts, and revocations describe a local operational decision. They should not become a hidden rule inside a portable repository. A fresh checkout should inherit documented project intent, not someone else's unreviewed tool grant.&lt;/p&gt;

&lt;p&gt;That separation also keeps responsibility clear. APC can explain &lt;em&gt;why&lt;/em&gt; a project needs a tool. APX asks a human &lt;em&gt;whether this agent may use it now&lt;/em&gt;, and for how long.&lt;/p&gt;

&lt;h2&gt;
  
  
  A small rule that scales
&lt;/h2&gt;

&lt;p&gt;Treat every broader scope as a new claim:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;This call is safe now.&lt;/li&gt;
&lt;li&gt;This conversation can repeat it.&lt;/li&gt;
&lt;li&gt;This agent may keep doing it later.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Each step needs more evidence than the last. A scope selector that reflects that difference turns permission from a vague comfort signal into an auditable control boundary.&lt;/p&gt;

&lt;p&gt;APC keeps project intent portable. APX keeps operational authority local, explicit, and revocable. That is slower than silently upgrading one approval into permanent trust—but much easier to trust in real work.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>devtools</category>
      <category>tutorial</category>
    </item>
  </channel>
</rss>
