<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>ACT Blog</title><description>Announcements, design notes, and deeper dives from the ACT team.</description><link>https://actcore.dev/</link><item><title>AI agent tools run with your permissions. They don&apos;t have to.</title><link>https://actcore.dev/blog/2026-10-05-sandboxed-agent-tools/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-10-05-sandboxed-agent-tools/</guid><description>Every MCP server you install executes as your user, with your files and keys in reach. ACT packages tools as WebAssembly components with a declared capability ceiling, explicit grants and an audit trail. Live demo: real pandas in your browser tab, touching one file.</description><pubDate>Mon, 05 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Every MCP server or agent tool you install today runs as your user. It sees
your SSH keys, your &lt;code&gt;.env&lt;/code&gt; files, the whole network. If it misbehaves, you
find out from the damage.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT&lt;/strong&gt;, short for Agent Component Tools, packages a tool as a single WebAssembly component.
The component declares what it needs, &lt;em&gt;this directory&lt;/em&gt; and &lt;em&gt;these hosts&lt;/em&gt;, and
the host enforces it: undeclared means denied; declared still waits for your
grant. Every decision lands in an audit trail. The same &lt;code&gt;.wasm&lt;/code&gt; file is an MCP
server (stdio or Streamable HTTP), a command-line tool, and a browser-tab app.&lt;/p&gt;
&lt;h2&gt;Try it in your browser&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://actcore.dev/python&quot;&gt;actcore.dev/python&lt;/a&gt; is real CPython with numpy and pandas, compiled
for WASI (not Pyodide, not Emscripten), executing your CSV inside the tab.
It can touch the one file you hand it and reach PyPI, nothing else. Pick the
&lt;strong&gt;escape&lt;/strong&gt; example: it asks the component to fetch from a non-PyPI host, and
the policy refuses before the request leaves the page.&lt;/p&gt;
&lt;p&gt;The first run downloads ~113 MB, once, and needs JSPI: Chrome/Edge 137+ or
Firefox 153+. Firefox ships it by default since 153; Chrome Android doesn&apos;t
have it yet, so phones are out for now.&lt;/p&gt;
&lt;h2&gt;Or from a terminal&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;https://actcore.dev/blog/act-terminal.gif&quot; alt=&quot;act info shows what a tool can touch, a grant covers one directory, and with no grant it asks&quot; /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;mkdir -p /tmp/demo
npx @actcore/act call actpkg.dev/library/sqlite query \
  --args &apos;{&quot;sql&quot;:&quot;SELECT sqlite_version()&quot;}&apos; \
  --session-args &apos;{&quot;database_path&quot;:&quot;/tmp/demo/app.db&quot;}&apos; \
  --allow &apos;fs=/tmp/demo/**&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;act info &amp;lt;component&amp;gt;&lt;/code&gt; shows what a tool can touch before it ever runs.
Without a grant, an interactive run &lt;strong&gt;asks&lt;/strong&gt; on first access and a headless
one denies. Every capability decision (allow, deny, ask, and the rule that
decided it) goes to the audit trail on stderr, independently of your logging
setup.&lt;/p&gt;
&lt;p&gt;The grant line above is one directory. &lt;code&gt;--allow &apos;http=https://api.example.com&apos;&lt;/code&gt;
is one host. &lt;code&gt;--deny &apos;fs=/data/secret/**&apos;&lt;/code&gt; carves a rule back out. A component
cannot get past what it declared, and you cannot accidentally grant more than
you named.&lt;/p&gt;
&lt;h2&gt;The ecosystem around it&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;act&lt;/code&gt;&lt;/strong&gt;, the host: Rust + wasmtime, MCP and CLI, capability policy, audit
trail. The current release, 0.14.4, tracks wasmtime 49.0.2 with this year&apos;s
engine security advisories closed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;act-build&lt;/code&gt;&lt;/strong&gt;: embeds component metadata and pushes to any OCI registry.
Published components are signed with keyless cosign in CI.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;23 components&lt;/strong&gt; on &lt;a href=&quot;https://actpkg.dev&quot;&gt;actpkg.dev&lt;/a&gt;: sqlite, postgres,
http-client, pdf, archive, the Python environment, browser automation over
WebDriver BiDi, a VNC desktop.&lt;/li&gt;
&lt;li&gt;Rust and Python SDKs; components in Go, C/C++, Zig, Kotlin and a few more
languages run the same way (experimental).&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;What it isn&apos;t&lt;/h2&gt;
&lt;p&gt;Not a VM. Isolation is WebAssembly (wasmtime in the CLI, the browser&apos;s own
engine in the tab) plus a capability policy on top. A native MCP server has
to be rebuilt as a component to get any of this; the SDKs make that a small
change, but it is a change.&lt;/p&gt;
&lt;h2&gt;Feedback wanted&lt;/h2&gt;
&lt;p&gt;The capability model is the part we&apos;d most like feedback on: what would you
need to see before letting a third-party tool run on your machine? The
&lt;a href=&quot;https://actcore.dev/docs/&quot;&gt;docs&lt;/a&gt; cover the &lt;a href=&quot;https://actcore.dev/docs/host/policy/&quot;&gt;policy model&lt;/a&gt; end to end, and
the code is at &lt;a href=&quot;https://github.com/actcore/act-cli&quot;&gt;github.com/actcore/act-cli&lt;/a&gt;
(MIT OR Apache-2.0).&lt;/p&gt;
</content:encoded><author>actcore</author></item><item><title>WASI Python in 2026: dlopen works, NumPy still doesn&apos;t</title><link>https://actcore.dev/blog/2026-05-18-wasi-python-numpy-state/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-05-18-wasi-python-numpy-state/</guid><description>A self-hosted Python sandbox for AI agents that can&apos;t import NumPy — and the surprise is that the blocker isn&apos;t the runtime anymore. A field report on the state of WASI Python in May 2026: the runtime is ready, PEP 816 just went Active, and the wheels are still ahead of us.</description><pubDate>Mon, 18 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; this has since been solved. The &lt;code&gt;python-env&lt;/code&gt; component now ships
&lt;strong&gt;numpy 2.5.0, pandas 3.0.3 and Pillow&lt;/strong&gt; compiled for wasm, using the WebAssembly
exception-handling proposal rather than the wheels this post was waiting on. You can run
pandas in a browser tab on the &lt;a href=&quot;https://actcore.dev/python&quot;&gt;Python playground&lt;/a&gt;. The analysis below is kept
as a record of where WASI Python stood in May 2026.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Three weeks ago I packaged a CPython 3.14 interpreter as a WebAssembly
component. The pitch is simple: AI agents need to execute untrusted
Python code, and today&apos;s options (&lt;a href=&quot;https://e2b.dev&quot;&gt;E2B&lt;/a&gt;,
&lt;a href=&quot;https://daytona.io&quot;&gt;Daytona&lt;/a&gt;, &lt;a href=&quot;https://modal.com&quot;&gt;Modal&lt;/a&gt;, Cloudflare
Sandboxes) are cloud microVMs with billing surfaces, network
requirements, and the trust boundary at someone else&apos;s organization. A
self-contained &lt;code&gt;.wasm&lt;/code&gt; you can ship anywhere — offline laptops,
regulated environments, even Android over &lt;code&gt;adb push&lt;/code&gt; — slots into a
different deployment story.&lt;/p&gt;
&lt;p&gt;The component works. You can do this:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;$ act call python-eval.wasm exec --args &apos;{&quot;code&quot;:&quot;print(sum(range(100)))&quot;}&apos;
4950
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;You can serve it over MCP (&lt;code&gt;act run python-eval.wasm --mcp&lt;/code&gt;) and any
agent that speaks the protocol can call &lt;code&gt;exec(code)&lt;/code&gt;. The host
controls what filesystem paths and HTTP hosts are mounted into the
guest, so a misbehaving snippet can&apos;t reach &lt;code&gt;/etc/passwd&lt;/code&gt; or the cloud
metadata service unless you explicitly allow it.&lt;/p&gt;
&lt;p&gt;But the moment you ask an agent to run &lt;code&gt;pd.read_csv()&lt;/code&gt; in there, the
answer is no. And when I went looking for the reason, the actual story
is the opposite of what I&apos;d been telling people. Here&apos;s the tour.&lt;/p&gt;
&lt;h2&gt;What I assumed: dlopen still doesn&apos;t work&lt;/h2&gt;
&lt;p&gt;I&apos;d internalised the 2023-era version of WASI Python: CPython compiled
to wasm32-wasip2 ran the stdlib fine, but native extensions
(&lt;code&gt;numpy._core._multiarray_umath&lt;/code&gt;, &lt;code&gt;pandas._libs.window&lt;/code&gt;, the C parts
of &lt;code&gt;cryptography&lt;/code&gt;) needed a working &lt;code&gt;dlopen&lt;/code&gt;, and &lt;code&gt;dlopen&lt;/code&gt; was
indefinitely &quot;experimental&quot; in WASI. componentize-py was riding a
&lt;a href=&quot;https://github.com/bytecodealliance/componentize-py/issues/113&quot;&gt;temporary fork of WASI-SDK&lt;/a&gt;
to get partial shared-library support, waiting for upstream to land
the work.&lt;/p&gt;
&lt;p&gt;That story stopped being true in 2025, and I missed the update.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;wasi-libc landed shared library support in September 2023&lt;/strong&gt;
(&lt;a href=&quot;https://github.com/WebAssembly/wasi-libc/pull/429&quot;&gt;PR #429&lt;/a&gt;),
followed by &lt;code&gt;dlopen&lt;/code&gt;/&lt;code&gt;dlsym&lt;/code&gt; stubs
(&lt;a href=&quot;https://github.com/WebAssembly/wasi-libc/pull/443&quot;&gt;PR #443&lt;/a&gt;,
November 2023).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;WASI-SDK 21 shipped functional &lt;code&gt;dlopen&lt;/code&gt;&lt;/strong&gt; in February 2024. Brett
Cannon&apos;s &lt;a href=&quot;https://discuss.python.org/t/cpython-now-compiles-and-passes-under-wasi-sdk-21/48514&quot;&gt;WASI Python milestone post&lt;/a&gt;
noted that with SDK 21 he no longer needed to patch CPython source
to make the test suite pass.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;componentize-py migrated to upstream WASI-SDK in October 2025.&lt;/strong&gt;
&lt;a href=&quot;https://github.com/bytecodealliance/componentize-py/issues/113&quot;&gt;Issue #113&lt;/a&gt;
(&quot;Update to latest WASI-SDK and the new &lt;code&gt;wasm32-wasip2&lt;/code&gt; target&quot;) was
closed completed on 2025-10-03 via PR #167; the project now ships
against upstream WASI-SDK v27, CPython 3.14, and Wasmtime 37.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https://peps.python.org/pep-0816/&quot;&gt;PEP 816&lt;/a&gt; went Active on
2026-02-26.&lt;/strong&gt; Brett Cannon submitted it to the Steering Council on
January 9; the SC approved it seven weeks later. The PEP locks down
a specific WASI version and WASI SDK version per CPython release,
treating WASI as a supported build platform with the same governance
commitments (PEP 11 entry, named maintainers, SC sign-off on version
changes) as Linux or macOS. CPython 3.13/3.14 are pegged to WASI
SDK 24; 3.15 will pick its baseline at beta 1.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The runtime piece, in other words, is essentially solved — and as of
just under three months ago, it has the governance scaffolding usually needed
before downstream maintainers commit work to a platform. The toolchain
you&apos;d want to compile NumPy against exists, ships from official
upstreams, and is on a published support roadmap.&lt;/p&gt;
&lt;p&gt;So why doesn&apos;t &lt;code&gt;import numpy&lt;/code&gt; work?&lt;/p&gt;
&lt;h2&gt;What&apos;s actually broken: the wheels&lt;/h2&gt;
&lt;p&gt;There are no WASI wheels on PyPI.&lt;/p&gt;
&lt;p&gt;For a package to be &lt;code&gt;pip install&lt;/code&gt;-able on WASI, the package needs to
be built against the WASI SDK CPython was compiled with, the resulting
artefact needs a platform tag (&lt;code&gt;wasi_0_2_x86_64-unknown&lt;/code&gt; or similar),
and PyPI needs to recognise that tag. None of the dozen scientific
Python projects I checked has any of these in their CI.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;NumPy upstream
&lt;a href=&quot;https://github.com/numpy/numpy/issues/25859&quot;&gt;issue #25859&lt;/a&gt;&lt;/strong&gt;, &quot;ENH:
WASI Build&quot;, asks for first-party WASI wheels. Opened 2024-02-21,
last meaningful update 2024-02-21. That two years of silence pre-dates
PEP 816 going Active, though — until February of this year, WASI
didn&apos;t have the governance commitment that would make a NumPy
maintainer prioritise the work over user-facing features. The
upstream issue hasn&apos;t caught up to the new context yet.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;PyPI doesn&apos;t yet have a published platform tag for WASI wheels.&lt;/strong&gt;
PEP 816 covers CPython&apos;s side of the contract; the wheel-side
story is in earlier motion. The
&lt;a href=&quot;https://peps.python.org/pep-0817/&quot;&gt;PEP 817 (Wheel Variants)&lt;/a&gt; draft,
posted December 2025, defines a generic variant-tagging framework
intended for GPU/BLAS/ABI selection — but the same provider-plugin
mechanism could plausibly host a &lt;code&gt;wasi_0_2_x86_64-unknown&lt;/code&gt; variant.
Whether that&apos;s the path or a dedicated WASI-tag PEP eventually
emerges is unclear from the public PyPA discussions.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;The only end-to-end demo of &quot;WASI Python with NumPy&quot; so far was
&lt;a href=&quot;https://github.com/dicej/wasi-wheels&quot;&gt;&lt;code&gt;wasi-wheels&lt;/code&gt;&lt;/a&gt;&lt;/strong&gt;, Joel Dice&apos;s
2023 build-script collection. Last release v0.0.1, December 2023.
README:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;This project is an experimental proof-of-concept. It is not being
actively maintained; the packages are out-of-date with respect to
their upstream versions, and might not even build anymore.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Two years of bit-rot against current Python releases, current
WASI-SDK, and current componentize-py snapshots. The pattern that&apos;s
been repeated for years — one motivated individual builds a demo, it
rots — needs to break, and PEP 816 is the first time the ecosystem
has had a credible reason to break it.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The blocker has moved from a runtime gap to a packaging-and-adoption
gap. Packaging gaps usually need broader coordination than a single
PR, but the early infrastructure is now landing: PEP 816 made the
runtime contract official in February, PEP 817 is moving on the
wheel-tagging side, and the runtime maintainers are visibly active
(componentize-py is shipping canaries against current upstream).
What&apos;s still missing is a scientific-Python maintainer or a funded
team picking up the build infrastructure. That&apos;s a question of months,
not weeks, but it&apos;s no longer &quot;if.&quot;&lt;/p&gt;
&lt;h2&gt;Pyodide is right there, but…&lt;/h2&gt;
&lt;p&gt;The obvious counter is: Pyodide already ships NumPy, Pandas, SciPy,
Matplotlib, scikit-learn — the whole scientific stack runs in the
browser today. So why not use Pyodide?&lt;/p&gt;
&lt;p&gt;Because Pyodide targets &lt;code&gt;wasm32-emscripten&lt;/code&gt;, not &lt;code&gt;wasm32-wasip2&lt;/code&gt;.
Emscripten is a different ABI: it provides a POSIX-flavoured runtime
backed by JavaScript-side shims, not WASI&apos;s import-based capability
model. A Pyodide build expects a JS environment that imports the
emscripten support library; it doesn&apos;t compose with the WebAssembly
Component Model the way a wasip2 build does.&lt;/p&gt;
&lt;p&gt;There&apos;s been periodic interest in a &quot;Pyodide on WASI&quot; port, but it&apos;s
a research project — closer to &quot;could work in a year&quot; than &quot;ship it
next week.&quot; Even if it landed, the bundled scientific stack would
weigh tens of megabytes per package; the single-&lt;code&gt;.wasm&lt;/code&gt;, drop-in
portability story gets harder to defend.&lt;/p&gt;
&lt;h2&gt;What we shipped instead&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;python-eval&lt;/code&gt; 0.3.0 ships with the Python stdlib only. The
&lt;a href=&quot;https://github.com/actpkg/python-eval&quot;&gt;README lists the limitation up front&lt;/a&gt;,
because watching agents fail to &lt;code&gt;import numpy&lt;/code&gt; with a confusing error
is a bad first experience.&lt;/p&gt;
&lt;p&gt;The slot we&apos;re now explicitly targeting is &lt;strong&gt;untrusted text-processing
and control-flow code&lt;/strong&gt;: regex, string parsing, JSON/CSV/XML
transformation, date math, plugin DSL evaluation, agent-generated
control logic. That covers a real and underserved chunk of agent
tool-use, and it doesn&apos;t compete with E2B&apos;s actual use cases (data
science with &lt;code&gt;pd.read_csv&lt;/code&gt; and &lt;code&gt;df.describe&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;Three system-prompt fragments are checked into the README, designed to
be pasted into a Claude/GPT agent&apos;s system block. The strict version:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;You have an &lt;code&gt;exec(code: str)&lt;/code&gt; tool that runs Python in a sandbox.
The sandbox has Python stdlib only — NO numpy, pandas, scipy,
sklearn, matplotlib, or any package with C extensions. No
networking unless the host has explicitly granted it. State does
NOT persist between calls — each &lt;code&gt;exec()&lt;/code&gt; runs in a fresh
namespace. Use &lt;code&gt;import&lt;/code&gt; for stdlib modules (re, json, datetime,
itertools, csv, etc). Print final results.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;LLMs handle this kind of constraint well when it&apos;s stated up front
and badly when they discover it via traceback.&lt;/p&gt;
&lt;h2&gt;What we&apos;re watching&lt;/h2&gt;
&lt;p&gt;The honest limitations list in the README is provisional. The
trajectory is reasonably clear; the timing is what&apos;s open. Three
signals will tell us when to revisit:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;PEP 817 (or a successor) lands a way to tag WASI wheels.&lt;/strong&gt; Once
PyPI can host &lt;code&gt;numpy-2.x-cp314-wasi_0_2_x86_64-unknown.whl&lt;/code&gt; artefacts
that &lt;code&gt;pip&lt;/code&gt; recognises, the path from &quot;NumPy maintainer pushes the
wheel&quot; to &quot;your component imports it&quot; becomes a single command.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;NumPy issue #25859 starts moving.&lt;/strong&gt; A first-party WASI wheel in
NumPy CI changes the calculus immediately — projects can vendor the
wheel directly even before PyPI catches up. PEP 816 going Active
removes the main reason a maintainer might have deferred this.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;A funded successor to wasi-wheels appears.&lt;/strong&gt; Astral, NumFOCUS,
the PSF, or one of the agentic-Python vendors picks up the build
infrastructure as a real product rather than a 2023 demo. The
maintenance burden is the actual blocker; one funded maintainer
shifts everything.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;None of these are &quot;if&quot;. They&apos;re &quot;when&quot;. Until then, the component
does what it does well, and the failure modes are documented at the
top of the page rather than buried in a traceback.&lt;/p&gt;
&lt;h2&gt;A note on positioning&lt;/h2&gt;
&lt;p&gt;I think the wasm Python conversation has a small honesty problem in
both directions. Posts that say &quot;run Python in WebAssembly&quot; usually
skip the part about which Python and which libraries — Pyodide&apos;s
scientific-stack story bleeds into expectations for every other wasm
Python runtime. The other direction is now mine to be careful about:
WASI Python in May 2026 isn&apos;t a stuck ecosystem, it&apos;s an ecosystem
with the runtime done and the package layer in motion. The first
release with PEP 816 governance went Active just under three months
ago. We don&apos;t have NumPy in &lt;code&gt;python-eval&lt;/code&gt; today, and I don&apos;t expect to
have it tomorrow, but I don&apos;t think the calendar arithmetic on &quot;when&quot;
is &quot;never&quot; any more.&lt;/p&gt;
&lt;p&gt;Saying &quot;stdlib only&quot; out loud is today&apos;s trust signal. The next
release will list one fewer caveat.&lt;/p&gt;
&lt;h2&gt;Where to find it&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Component: &lt;a href=&quot;https://github.com/actpkg/python-eval&quot;&gt;&lt;code&gt;actpkg/python-eval&lt;/code&gt;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Host: &lt;a href=&quot;https://github.com/actcore/act-cli&quot;&gt;&lt;code&gt;act&lt;/code&gt; CLI&lt;/a&gt; — runs
components over MCP, ACT-HTTP, or one-shot from the terminal&lt;/li&gt;
&lt;li&gt;Spec: &lt;a href=&quot;https://github.com/actcore/act-spec&quot;&gt;&lt;code&gt;act-spec&lt;/code&gt;&lt;/a&gt; — the
underlying protocol, designed component-first rather than
transport-first&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If you&apos;re working on the wheel-tag PEP, building NumPy WASI in CI, or
have a funded maintenance plan for a wasi-wheels successor, please get
in &lt;a href=&quot;https://github.com/actcore/act-spec/discussions&quot;&gt;touch&lt;/a&gt;. The
limitations section will only get shorter with help.&lt;/p&gt;
</content:encoded><author>actcore</author></item><item><title>ACT 0.7: sessions, three production bridges, and auth-via-args</title><link>https://actcore.dev/blog/2026-05-07-act-07-sessions/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-05-07-act-07-sessions/</guid><description>Components can now own per-session state through `act:sessions/session-provider` — a small WIT interface for components that need to hold a database connection, a parsed OpenAPI spec, or an upstream MCP handshake. Three bridges in `actpkg` are rebuilt around it: act-http-bridge, mcp-bridge, openapi-bridge. Auth moves into open-session args, where it belongs.</description><pubDate>Thu, 07 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; ACT-HTTP — the REST binding with &lt;code&gt;/info&lt;/code&gt;, &lt;code&gt;/tools&lt;/code&gt; and
&lt;code&gt;/sessions&lt;/code&gt; — was removed in &lt;code&gt;act&lt;/code&gt; 0.12.0. MCP is now ACT&apos;s transport on the wire:
use &lt;code&gt;--mcp&lt;/code&gt; for stdio or &lt;code&gt;--mcp --http&lt;/code&gt; for MCP over Streamable HTTP at &lt;code&gt;/mcp&lt;/code&gt;.
The commands below that use &lt;code&gt;act run --http&lt;/code&gt; no longer work as written; everything
about sessions and components themselves still holds. See
&lt;a href=&quot;https://actcore.dev/docs/host/transports/&quot;&gt;Transports&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; the per-class policy flags used below — &lt;code&gt;--fs-policy&lt;/code&gt;,
&lt;code&gt;--fs-allow&lt;/code&gt;, &lt;code&gt;--http-policy&lt;/code&gt;, &lt;code&gt;--http-allow&lt;/code&gt; and friends — were replaced by a uniform
grant model (&lt;code&gt;--grant&lt;/code&gt;, &lt;code&gt;--allow&lt;/code&gt;, &lt;code&gt;--deny&lt;/code&gt;), and the default mode is now &lt;code&gt;ask&lt;/code&gt; rather
than deny. The capability-ceiling model this post describes is unchanged; only the flag
spelling is. See &lt;a href=&quot;https://actcore.dev/docs/host/policy/&quot;&gt;Policy &amp;amp; sandbox&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;The previous posts focused on what ACT &lt;em&gt;is&lt;/em&gt; — sandboxed components, one
binary per transport, capability ceilings. This one is about a thing
that was missing: &lt;strong&gt;state&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Most of the components on &lt;code&gt;actpkg&lt;/code&gt; are pure request/response — &lt;code&gt;crypto&lt;/code&gt;,
&lt;code&gt;encoding&lt;/code&gt;, &lt;code&gt;random&lt;/code&gt;, &lt;code&gt;time&lt;/code&gt;. They don&apos;t need a session because every
call is independent. But the moment you reach for tools that &lt;em&gt;do&lt;/em&gt; —
a database connection, an OpenAPI client that has parsed a 5MB spec, an
MCP bridge mid-handshake with an upstream server — there&apos;s nowhere to
put that state. Components held it in &lt;code&gt;thread_local!&lt;/code&gt; HashMaps keyed by
&lt;code&gt;std:session-id&lt;/code&gt; metadata, and the host had no idea what those ids
meant or when to clean them up.&lt;/p&gt;
&lt;p&gt;ACT 0.7 fixes that. Stateful components now opt into a small new WIT
interface, &lt;code&gt;act:sessions/session-provider@0.1.0&lt;/code&gt;. The interface is
deliberately tiny — three functions — and it changes nothing for the
80% of components that don&apos;t need it.&lt;/p&gt;
&lt;h2&gt;The interface&lt;/h2&gt;
&lt;pre&gt;&lt;code class=&quot;language-wit&quot;&gt;package act:sessions@0.1.0;

interface session-provider {
  use act:core/types@0.4.0.{metadata, error};

  record session {
    id: string,
    metadata: metadata,
  }

  /// JSON Schema describing valid args for `open-session`.
  /// Hosts use this to validate before they invoke the component.
  get-open-session-args-schema: async func(metadata: metadata)
    -&amp;gt; result&amp;lt;string, error&amp;gt;;

  /// Open a session. `args` carries connection params and credentials.
  open-session: async func(args: metadata, metadata: metadata)
    -&amp;gt; result&amp;lt;session, error&amp;gt;;

  /// Polite shutdown — sync, advisory. The host MUST call this for
  /// every session it opened, before component deinit.
  close-session: func(session-id: string);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Subsequent capability calls (&lt;code&gt;tool-provider.list-tools&lt;/code&gt;,
&lt;code&gt;tool-provider.call-tool&lt;/code&gt;) pass the returned &lt;code&gt;id&lt;/code&gt; as &lt;code&gt;std:session-id&lt;/code&gt;
in their metadata. The component does its own state lookup. The host
keeps the wasm instance alive as long as it&apos;s serving sessions, and
closes whatever&apos;s still open before it tears the instance down.&lt;/p&gt;
&lt;p&gt;If you used the old &lt;code&gt;metadata = {&quot;url&quot;: &quot;...&quot;}&lt;/code&gt; shape on the bridges,
this is a breaking change. The reasoning is in the next section.&lt;/p&gt;
&lt;h2&gt;Three bridges, rebuilt&lt;/h2&gt;
&lt;p&gt;The whole reason &lt;code&gt;act:sessions&lt;/code&gt; exists is that bridges need it. Three
of them just shipped on the new model:&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/mcp-bridge&quot;&gt;&lt;code&gt;mcp-bridge&lt;/code&gt;&lt;/a&gt; 0.2.0&lt;/h3&gt;
&lt;p&gt;Wraps a remote MCP server, exposes its tools as ACT tools.
&lt;code&gt;open-session&lt;/code&gt; does the MCP &lt;code&gt;initialize&lt;/code&gt; + &lt;code&gt;notifications/initialized&lt;/code&gt;
handshake against the upstream and stashes the resulting
&lt;code&gt;Mcp-Session-Id&lt;/code&gt; header for the lifetime of the session. The bridge
issues its own outward-facing id and maps the two NAT-style — agents
never see the upstream&apos;s id, so swapping upstream-session-ids on
expiry is invisible from the agent&apos;s side.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;act run actpkg.dev/library/mcp-bridge:latest --mcp
# then, agent: open_session({&quot;url&quot;: &quot;https://upstream.example/mcp&quot;, &quot;auth_token&quot;: &quot;sk-...&quot;})
#         →  {&quot;id&quot;: &quot;mcp_0&quot;, &quot;metadata&quot;: {}}
# then, agent: tools/list with _meta.std:session-id = mcp_0
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/openapi-bridge&quot;&gt;&lt;code&gt;openapi-bridge&lt;/code&gt;&lt;/a&gt; 0.2.0&lt;/h3&gt;
&lt;p&gt;Loads an OpenAPI 3.x spec at runtime and exposes each operation as a
local ACT tool. &lt;code&gt;open-session({spec_url, headers})&lt;/code&gt; fetches and parses
the spec eagerly, so connect or parse failures surface at open time
rather than 17 tool calls later. Path/query/header parameters and
JSON request bodies are flattened into a single tool argument schema,
auto-named from &lt;code&gt;operationId&lt;/code&gt; (or synthesised from method + path).&lt;/p&gt;
&lt;p&gt;The parsed spec is cached by &lt;code&gt;spec_url&lt;/code&gt; so multiple sessions targeting
the same API share the parse — opening 10 sessions for the same spec
costs one fetch.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/act-http-bridge&quot;&gt;&lt;code&gt;act-http-bridge&lt;/code&gt;&lt;/a&gt; 0.2.0&lt;/h3&gt;
&lt;p&gt;The simplest of the three. Proxies a remote ACT-HTTP host as local ACT
tools. &lt;code&gt;open-session({url, headers})&lt;/code&gt;, then any &lt;code&gt;list-tools&lt;/code&gt; /
&lt;code&gt;call-tool&lt;/code&gt; is forwarded to the upstream component over HTTP. Useful
when you want one local component to delegate to a fleet of remote
ACT components without mounting all of them in your host config.&lt;/p&gt;
&lt;h2&gt;Auth lives in open-session, not metadata&lt;/h2&gt;
&lt;p&gt;Until 0.7, &lt;code&gt;mcp-bridge&lt;/code&gt; accepted &lt;code&gt;auth_token&lt;/code&gt; as &lt;code&gt;metadata&lt;/code&gt; on every
call. That was wrong on three counts.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Auth is per-session, not per-call.&lt;/strong&gt; Once you&apos;ve authenticated to
the upstream, every subsequent call within that session uses the same
identity. Stuffing the bearer into every &lt;code&gt;tools/call&lt;/code&gt; is duplication
and a bug surface — what if some client puts it in some calls and not
others?&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Auth has a schema.&lt;/strong&gt; OAuth wants a token. HTTP basic wants a
username and password. mTLS wants a key and cert. Different per-component.
&lt;code&gt;open-session.args&lt;/code&gt; is component-defined, validated by the host
against the schema returned from &lt;code&gt;get-open-session-args-schema&lt;/code&gt; before
the credentials ever touch the wasm. There&apos;s no place in &lt;code&gt;metadata&lt;/code&gt;
to carry that schema.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Auth lives at one boundary.&lt;/strong&gt; With session args, the bearer flows
once: host configuration → host validation → wasm via &lt;code&gt;open-session&lt;/code&gt;.
After that, the agent only ever sees the opaque session-id. If the
session-id leaks, the agent gets capability the operator already
granted. If the bearer leaked from per-call metadata, the agent —
or whoever observed metadata in transit — would have the upstream
credential itself.&lt;/p&gt;
&lt;p&gt;Full guidance is in
&lt;a href=&quot;https://github.com/actcore/act-spec/blob/main/spec/ACT-AUTH.md&quot;&gt;&lt;code&gt;ACT-AUTH.md&lt;/code&gt;&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Transport plumbing&lt;/h2&gt;
&lt;p&gt;The host exposes session lifecycle on the wires it already speaks.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT-HTTP&lt;/strong&gt; gains three endpoints (per
&lt;a href=&quot;https://github.com/actcore/act-spec/blob/main/spec/ACT-SESSIONS.md#62-act-http&quot;&gt;ACT-SESSIONS §6.2&lt;/a&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;POST  /sessions/open-args-schema   → JSON Schema (metadata in body)
POST  /sessions                    → 201 with session record
DELETE /sessions/{id}              → 204
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Subsequent capability calls reference the session via &lt;code&gt;std:session-id&lt;/code&gt;
in request body metadata or the &lt;code&gt;X-Act-Session-Id&lt;/code&gt; header.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;MCP&lt;/strong&gt; synthesises two virtual tools whenever the underlying
component exports session-provider — &lt;code&gt;open_session&lt;/code&gt; and
&lt;code&gt;close_session&lt;/code&gt;, with &lt;code&gt;_meta.std:session-op&lt;/code&gt; annotations so agents
recognise them as lifecycle ops, not ordinary capabilities. The agent
calls &lt;code&gt;open_session&lt;/code&gt; once, threads &lt;code&gt;_meta.std:session-id&lt;/code&gt; into every
subsequent &lt;code&gt;tools/call&lt;/code&gt;, and finally calls &lt;code&gt;close_session&lt;/code&gt;. The host
also forwards any &lt;code&gt;_meta&lt;/code&gt; keys from the agent into the WIT call
metadata, so &lt;code&gt;std:session-id&lt;/code&gt; reaches the component without any
host-side translation.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT-CLI&lt;/strong&gt; picks up a new flag, &lt;code&gt;act call --session-args&lt;/code&gt;. The host
opens a session, threads the returned id into the call&apos;s metadata as
&lt;code&gt;std:session-id&lt;/code&gt;, runs the tool, and closes the session — all in one
process, so the wasm instance stays alive for the full sequence.&lt;/p&gt;
&lt;p&gt;A self-contained demo: serve the &lt;code&gt;time&lt;/code&gt; component locally, then
proxy through &lt;code&gt;act-http-bridge&lt;/code&gt; and call it through the proxy.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;# Terminal 1 — upstream ACT-HTTP server.
act run actpkg.dev/library/time:latest --http -l &apos;[::1]:3000&apos;

# Terminal 2 — one-shot call through the bridge.
act call actpkg.dev/library/act-http-bridge:latest get_current_time \
  --args &apos;{}&apos; \
  --session-args &apos;{&quot;url&quot;:&quot;http://[::1]:3000&quot;}&apos; \
  --http-policy open
# 2026-05-07T12:00:00.000+00:00
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The bridge instance opens a session that owns the upstream URL, calls
&lt;code&gt;get_current_time&lt;/code&gt; through it, closes the session, and exits. With an
&lt;code&gt;openapi-bridge&lt;/code&gt; instead of &lt;code&gt;act-http-bridge&lt;/code&gt; and &lt;code&gt;--session-args &apos;{&quot;spec_url&quot;:&quot;...&quot;}&apos;&lt;/code&gt; instead of &lt;code&gt;{&quot;url&quot;:&quot;...&quot;}&apos;&lt;/code&gt;, the same shape
works for any OpenAPI 3.x spec.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;act session open-args-schema&lt;/code&gt; is also still there for inspecting a
component&apos;s session args. Earlier 0.7.0 shipped &lt;code&gt;act session open&lt;/code&gt; and
&lt;code&gt;act session close&lt;/code&gt; as separate subcommands, but those were useless:
each invocation is a one-shot process whose wasm instance dies on
exit, so a session opened in one process is unreachable from a later
&lt;code&gt;call&lt;/code&gt;. They were removed in 0.7.1, and &lt;code&gt;--session-args&lt;/code&gt; replaces
both of them with the right shape — the open/call/close cycle in one
process — in 0.7.2.&lt;/p&gt;
&lt;h2&gt;SDK ergonomics&lt;/h2&gt;
&lt;p&gt;For Rust components, the new
&lt;a href=&quot;https://github.com/actcore/act-sdk-rs/blob/main/act-sdk-macros/src/lib.rs&quot;&gt;&lt;code&gt;#[session_open]&lt;/code&gt; / &lt;code&gt;#[session_close]&lt;/code&gt;&lt;/a&gt;
markers on top of &lt;code&gt;act_sdk::SessionRegistry&amp;lt;T&amp;gt;&lt;/code&gt; keep the boilerplate
small:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-rust&quot;&gt;use act_sdk::prelude::*;
use act_sdk::SessionRegistry;

#[act_component(name = &quot;counter&quot;)]
mod component {
    use super::*;

    pub struct Counter { value: u64 }

    thread_local! {
        static SESSIONS: SessionRegistry&amp;lt;Counter&amp;gt; =
            SessionRegistry::new(&quot;ctr&quot;);
    }

    #[derive(Deserialize, JsonSchema)]
    struct OpenArgs {
        #[serde(default)]
        start: u64,
    }

    #[session_open]
    fn open(args: OpenArgs) -&amp;gt; ActResult&amp;lt;String&amp;gt; {
        Ok(SESSIONS.with(|r| r.insert(Counter { value: args.start })))
    }

    #[session_close]
    fn close(id: String) {
        SESSIONS.with(|r| { r.remove(&amp;amp;id); });
    }

    // Tools read std:session-id via ActContext&amp;lt;MetaStruct&amp;gt;.
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The macro derives &lt;code&gt;get-open-session-args-schema&lt;/code&gt; from &lt;code&gt;OpenArgs&lt;/code&gt; via
&lt;code&gt;schemars&lt;/code&gt;, decodes the metadata-shaped wire args into the typed
struct, and emits the full session-provider Guest impl. The full
runnable example is
&lt;a href=&quot;https://github.com/actcore/act-sdk-rs/tree/main/examples/sessions-counter&quot;&gt;examples/sessions-counter&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Components with dynamic tool catalogs — every bridge — currently
hand-roll &lt;code&gt;wit_bindgen::generate!&lt;/code&gt; because &lt;code&gt;#[act_component]&lt;/code&gt; only
emits a static &lt;code&gt;list-tools&lt;/code&gt; from &lt;code&gt;#[act_tool]&lt;/code&gt; declarations. That&apos;s a
known gap; an SDK-side affordance for dynamic catalogs is on the list.&lt;/p&gt;
&lt;h2&gt;What&apos;s next&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Host-side OAuth.&lt;/strong&gt; ACT-AUTH describes how a host reads
&lt;code&gt;x-act-authorization-server&lt;/code&gt; and &lt;code&gt;x-act-scopes&lt;/code&gt; annotations on the
open-session schema, runs the OAuth flow, and injects the bearer
into args before calling &lt;code&gt;open-session&lt;/code&gt;. The annotations are
spec&apos;d; the host implementation isn&apos;t there yet.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Auto-open from host config for &lt;code&gt;--mcp&lt;/code&gt; / &lt;code&gt;--http&lt;/code&gt;.&lt;/strong&gt; &lt;code&gt;act call&lt;/code&gt;
now opens / closes per-invocation via &lt;code&gt;--session-args&lt;/code&gt;, but for the
long-running transports the agent still has to call &lt;code&gt;open_session&lt;/code&gt;
itself. For &quot;I always want this OpenAPI / MCP server / API&quot;
configurations, the host should pre-open the session at startup
from config, so the agent sees ordinary tools and never thinks
about the session at all.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Postgres component.&lt;/strong&gt; A component that authenticates via
&lt;code&gt;open-session.args&lt;/code&gt;, holds a real connection through the session,
and does parameterised queries through the tools. Not ready yet —
this&apos;ll be the first non-bridge stateful component on &lt;code&gt;actpkg&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;SessionContext&amp;lt;T&amp;gt;&lt;/code&gt; SDK sugar.&lt;/strong&gt; Drop the
&lt;code&gt;ToolMeta { #[serde(rename = &quot;std:session-id&quot;)] session_id }&lt;/code&gt;
boilerplate components currently write to read the session-id.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If you&apos;ve got an OpenAPI spec, a remote MCP server, or an internal
ACT-HTTP fleet, the bridges are running on &lt;code&gt;actpkg.dev/library&lt;/code&gt; ready for
&lt;code&gt;act run --mcp&lt;/code&gt;. If you want to write a stateful component yourself,
the &lt;a href=&quot;https://github.com/actcore/act-sdk-rs/tree/main/examples/sessions-counter&quot;&gt;sessions-counter
example&lt;/a&gt;
is the smallest working template. Issues, ideas, and &quot;this looks like
what I&apos;d want for X but Y is missing&quot; reports are welcome at
&lt;a href=&quot;https://github.com/actcore&quot;&gt;github.com/actcore&lt;/a&gt;.&lt;/p&gt;
</content:encoded><author>actcore</author></item><item><title>A tour of actpkg — components on the protocol</title><link>https://actcore.dev/blog/2026-04-25-eleven-components/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-04-25-eleven-components/</guid><description>A protocol is only interesting if people actually write for it. Here&apos;s what&apos;s published on actpkg today — storage, network bridges, utilities, language embedders — and what each one is for.</description><pubDate>Sat, 25 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; the per-class policy flags used below — &lt;code&gt;--fs-policy&lt;/code&gt;,
&lt;code&gt;--fs-allow&lt;/code&gt;, &lt;code&gt;--http-policy&lt;/code&gt;, &lt;code&gt;--http-allow&lt;/code&gt; and friends — were replaced by a uniform
grant model (&lt;code&gt;--grant&lt;/code&gt;, &lt;code&gt;--allow&lt;/code&gt;, &lt;code&gt;--deny&lt;/code&gt;), and the default mode is now &lt;code&gt;ask&lt;/code&gt; rather
than deny. The capability-ceiling model this post describes is unchanged; only the flag
spelling is. See &lt;a href=&quot;https://actcore.dev/docs/host/policy/&quot;&gt;Policy &amp;amp; sandbox&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;The core ACT spec is small: a tool-dispatch interface and a few CBOR
shapes on the wire, with stateful capabilities (sessions, events,
resources) layered on as separate opt-in packages. But a protocol is
only interesting if people actually write for it. Here&apos;s what&apos;s on
&lt;code&gt;actpkg.dev/library&lt;/code&gt; today, grouped by kind.&lt;/p&gt;
&lt;p&gt;Every component is MIT-or-Apache-2.0, published with signed
attestations, and runnable with:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;npx @actcore/act info actpkg.dev/library/&amp;lt;name&amp;gt;:latest --tools
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;Data &amp;amp; storage&lt;/h2&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/sqlite&quot;&gt;&lt;code&gt;sqlite&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;A SQLite database as a component. Exposes &lt;code&gt;query&lt;/code&gt;, &lt;code&gt;exec&lt;/code&gt;,
&lt;code&gt;batch-exec&lt;/code&gt;, &lt;code&gt;schema&lt;/code&gt;. Uses &lt;code&gt;rusqlite&lt;/code&gt; compiled to wasm32-wasip2
with the wasi-sdk toolchain; the database file is whatever path the
operator grants via &lt;code&gt;--fs-allow&lt;/code&gt;.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;npx @actcore/act run actpkg.dev/library/sqlite:latest --mcp \
  --fs-policy allowlist --fs-allow /data/app.sqlite
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Also ships a &lt;code&gt;sqlite-vec&lt;/code&gt; variant with &lt;a href=&quot;https://github.com/asg017/sqlite-vec&quot;&gt;sqlite-vec&lt;/a&gt; linked in
for vector-index queries. Same interface, one extra build target.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/filesystem&quot;&gt;&lt;code&gt;filesystem&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Generic &lt;code&gt;read&lt;/code&gt;, &lt;code&gt;write&lt;/code&gt;, &lt;code&gt;list&lt;/code&gt;, &lt;code&gt;stat&lt;/code&gt;, &lt;code&gt;delete&lt;/code&gt; over the component&apos;s
filesystem capability grant. Good when an agent needs &quot;edit a file&quot; and
you don&apos;t want to ship a language-specific MCP server.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/openwallet&quot;&gt;&lt;code&gt;openwallet&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;&lt;a href=&quot;https://openwallet.foundation/&quot;&gt;OpenWallet&lt;/a&gt;-compatible local key
storage. Stores seed phrases and derived keys on the filesystem under
the operator-granted vault path.&lt;/p&gt;
&lt;h2&gt;Network bridges&lt;/h2&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/http-client&quot;&gt;&lt;code&gt;http-client&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt; with full header / body control. The
component declares &lt;code&gt;wasi:http&lt;/code&gt; with whatever hosts the operator lets
it reach. Useful when you want a component (not the host) to do the
fetching — for example, from inside a bridge.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/openapi-bridge&quot;&gt;&lt;code&gt;openapi-bridge&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Point it at &lt;strong&gt;any&lt;/strong&gt; OpenAPI 3.x spec. The spec URL travels through
&lt;code&gt;open-session&lt;/code&gt; args (typed schema, validated host-side); the bridge
fetches and parses the spec, then exposes each operation as a tool.
One component fronts anything — Stripe, GitHub, your internal API,
the Petstore reference — with one capability grant per upstream:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;act call actpkg.dev/library/openapi-bridge:latest find_pets_by_status \
  --args &apos;{&quot;status&quot;:&quot;sold&quot;}&apos; \
  --session-args &apos;{&quot;spec_url&quot;:&quot;https://api.example.com/openapi.json&quot;}&apos; \
  --http-policy allowlist --http-allow host=api.example.com
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/mcp-bridge&quot;&gt;&lt;code&gt;mcp-bridge&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Reverse adapter: wraps an upstream MCP server (Streamable HTTP
transport) and re-exposes its tools through the ACT protocol. Lets
you connect an existing MCP ecosystem to ACT-native clients, or put
an ACT policy layer in front of an unsandboxed MCP server you don&apos;t
fully trust.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/act-http-bridge&quot;&gt;&lt;code&gt;act-http-bridge&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Symmetric: wraps a remote ACT-HTTP server behind a local component.
Useful for fronting a team-hosted service as a local-looking tool.&lt;/p&gt;
&lt;p&gt;All three bridges are session-based: the upstream URL and any
credentials live inside &lt;code&gt;open-session.args&lt;/code&gt; rather than per-call
metadata. See &lt;a href=&quot;https://actcore.dev/blog/2026-05-07-act-07-sessions/&quot;&gt;the sessions and bridges
post&lt;/a&gt; for the architecture and
why authentication ended up there.&lt;/p&gt;
&lt;h2&gt;Utilities&lt;/h2&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/crypto&quot;&gt;&lt;code&gt;crypto&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;SHA-256, SHA-512, BLAKE3, HMAC, Ed25519, X25519. All standard-lib
algorithms behind a clean tool surface. Useful when a script needs a
hash without pulling in a language-specific crypto package.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/encoding&quot;&gt;&lt;code&gt;encoding&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Base64, base64url, base32, hex, percent encoding, UUID parsing. The
one tool everyone writes a hundred times.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/random&quot;&gt;&lt;code&gt;random&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Cryptographically secure random strings, UUIDs (v4 and v7), and
integers in a range. LLMs cannot generate true randomness —
components can.&lt;/p&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/time&quot;&gt;&lt;code&gt;time&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;Clock access, timezone conversions, duration math. Pure wasip2, no
host dependencies.&lt;/p&gt;
&lt;h2&gt;Language embedders&lt;/h2&gt;
&lt;h3&gt;&lt;a href=&quot;https://github.com/actpkg/python-eval&quot;&gt;&lt;code&gt;python-eval&lt;/code&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;An entire CPython interpreter baked into a wasm component via &lt;a href=&quot;https://github.com/bytecodealliance/componentize-py&quot;&gt;&lt;code&gt;componentize-py&lt;/code&gt;&lt;/a&gt;.
Takes a string of Python, runs it in a fresh namespace, returns
stdout + the last-expression value. Demonstrates that &quot;running
untrusted code&quot; is a fair thing to do under the ACT sandbox because
the ceiling is explicit.&lt;/p&gt;
&lt;p&gt;Coming up:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;js-eval&lt;/code&gt;&lt;/strong&gt; — SpiderMonkey via componentize-js. Blocked on
&lt;a href=&quot;https://github.com/bytecodealliance/ComponentizeJS/issues/335&quot;&gt;async-export support upstream&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Categorize the pattern&lt;/h2&gt;
&lt;p&gt;Looking across the catalog, three patterns stand out:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Data-plane components&lt;/strong&gt; own state on disk under an operator
grant (&lt;code&gt;sqlite&lt;/code&gt;, &lt;code&gt;filesystem&lt;/code&gt;, &lt;code&gt;openwallet&lt;/code&gt;). The operator&apos;s
filesystem allow-list is the total exposure.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Bridge components&lt;/strong&gt; translate an external protocol into ACT
(&lt;code&gt;openapi-bridge&lt;/code&gt;, &lt;code&gt;mcp-bridge&lt;/code&gt;, &lt;code&gt;act-http-bridge&lt;/code&gt;). One component
covers a whole class of upstream — point it at a different URL
via &lt;code&gt;open-session&lt;/code&gt; and it fronts a different upstream.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Pure functions&lt;/strong&gt; do computation with no I/O beyond the call
boundary (&lt;code&gt;crypto&lt;/code&gt;, &lt;code&gt;encoding&lt;/code&gt;, &lt;code&gt;random&lt;/code&gt;, &lt;code&gt;time&lt;/code&gt;). No capabilities
declared at all — hard-deny on anything the operator tries to
grant.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Bridges are where the compounding happens. One &lt;code&gt;openapi-bridge&lt;/code&gt;
becomes &lt;code&gt;stripe&lt;/code&gt;, &lt;code&gt;github&lt;/code&gt;, &lt;code&gt;linear&lt;/code&gt;, &lt;code&gt;anything-that-ships-OpenAPI&lt;/code&gt;
— each as its own session against the same component, costing one
capability grant per upstream host.&lt;/p&gt;
&lt;h2&gt;Publishing your own&lt;/h2&gt;
&lt;p&gt;The workflow is small enough to describe in a paragraph:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Scaffold from the Rust or Python template:
&lt;code&gt;copier copy gh:actcore/act-template-rust my-component&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Write tools with &lt;code&gt;#[act_tool]&lt;/code&gt; / &lt;code&gt;@tool&lt;/code&gt;. Declare capabilities in
&lt;code&gt;act.toml&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;just build &amp;amp;&amp;amp; just test&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Push to &lt;code&gt;actcore/projects/my-component&lt;/code&gt; or your own namespace.
CI runs &lt;code&gt;just publish&lt;/code&gt; on &lt;code&gt;main&lt;/code&gt;, which &lt;code&gt;oras push&lt;/code&gt;es to
&lt;code&gt;ghcr.io/&amp;lt;ns&amp;gt;/my-component:&amp;lt;version&amp;gt;&lt;/code&gt; with a GitHub attestation.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Any OCI registry works. Any CI works. The artifact ends up
discoverable by &lt;code&gt;act pull&lt;/code&gt; and usable by &lt;code&gt;act run&lt;/code&gt; on every
platform.&lt;/p&gt;
&lt;h2&gt;What&apos;s missing&lt;/h2&gt;
&lt;p&gt;Plenty.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;JavaScript SDK (blocked upstream).&lt;/li&gt;
&lt;li&gt;MoonBit (blocked on a wit-bindgen-moonbit export bug).&lt;/li&gt;
&lt;li&gt;More bridges — A2A, AGNTCY, LSP over TCP are on the backlog.&lt;/li&gt;
&lt;li&gt;A proper &lt;code&gt;act-toolserver&lt;/code&gt; that composes several components with a
shared policy engine. That&apos;s the next large piece.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If any of the categories above are missing a component you&apos;d reach
for, &lt;a href=&quot;https://github.com/actcore/act-cli/issues&quot;&gt;open an issue&lt;/a&gt; — or
publish it yourself.&lt;/p&gt;
</content:encoded><author>actcore</author></item><item><title>The capability ceiling — how ACT sandboxes third-party tools</title><link>https://actcore.dev/blog/2026-04-24-capability-ceiling/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-04-24-capability-ceiling/</guid><description>ACT layers a declaration-as-ceiling policy model on top of WASI&apos;s capability imports and wasmtime&apos;s VM isolation. The declared ceiling, runtime policy, DNS-layer deny-CIDR, and per-hop redirect re-check combine to make a tool from an untrusted author safe to run under your agent.</description><pubDate>Fri, 24 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; the per-class policy flags used below — &lt;code&gt;--fs-policy&lt;/code&gt;,
&lt;code&gt;--fs-allow&lt;/code&gt;, &lt;code&gt;--http-policy&lt;/code&gt;, &lt;code&gt;--http-allow&lt;/code&gt; and friends — were replaced by a uniform
grant model (&lt;code&gt;--grant&lt;/code&gt;, &lt;code&gt;--allow&lt;/code&gt;, &lt;code&gt;--deny&lt;/code&gt;), and the default mode is now &lt;code&gt;ask&lt;/code&gt; rather
than deny. The capability-ceiling model this post describes is unchanged; only the flag
spelling is. See &lt;a href=&quot;https://actcore.dev/docs/host/policy/&quot;&gt;Policy &amp;amp; sandbox&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Handing a third-party tool to your AI agent is the same problem as
handing a third-party binary to &lt;code&gt;cron&lt;/code&gt;. The tool&apos;s author may be a
good actor or not. The agent may misuse the tool or not. The
operator — you — wants a floor on how bad either outcome can get.&lt;/p&gt;
&lt;p&gt;ACT&apos;s policy layer is about installing that floor. This post walks
through how it works, from the wasmtime VM up to the DNS resolver.&lt;/p&gt;
&lt;h2&gt;Three layers, explicit&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;┌─────────────────────────────────────────────────────┐
│  ACT policy (declaration × operator intent)         │ ← what this post is about
├─────────────────────────────────────────────────────┤
│  WASI capabilities (wasi:filesystem, wasi:http, …)  │ ← capability imports
├─────────────────────────────────────────────────────┤
│  wasmtime VM (JIT, linear memory, no host syscalls) │ ← isolation
└─────────────────────────────────────────────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Confusing the bottom two layers is a common trap. The &lt;strong&gt;isolation&lt;/strong&gt;
is wasmtime: a full WebAssembly VM with a JIT, linear-memory
boundaries, and no direct syscall access. A component can&apos;t read
&lt;code&gt;/etc/passwd&lt;/code&gt;, open a raw socket, or &lt;code&gt;execve&lt;/code&gt;. It can only call
imports the host chose to wire up.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;WASI&lt;/strong&gt; is the capability-oriented I/O surface. A component asks
for imports like &lt;code&gt;wasi:filesystem&lt;/code&gt; or &lt;code&gt;wasi:http&lt;/code&gt;; the host either
provides them, provides a gated shim, or leaves them unlinked. Those
imports are positive-only — there&apos;s no &quot;deny&quot; at the capability
level; a component either has the import or it doesn&apos;t.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT policy&lt;/strong&gt; is the layer this post is about. It sits between the
component&apos;s declared capability &lt;em&gt;intent&lt;/em&gt; and the operator&apos;s runtime
&lt;em&gt;grants&lt;/em&gt;, and makes sure neither side escalates past the other.&lt;/p&gt;
&lt;h2&gt;Declarations are ceilings&lt;/h2&gt;
&lt;p&gt;Every ACT component ships a manifest (&lt;code&gt;act.toml&lt;/code&gt; or a merged
equivalent from &lt;code&gt;Cargo.toml&lt;/code&gt; / &lt;code&gt;pyproject.toml&lt;/code&gt; / &lt;code&gt;package.json&lt;/code&gt;).
If it needs filesystem access, it must declare it:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-toml&quot;&gt;[std.capabilities.&quot;wasi:filesystem&quot;]
description = &quot;Stores the database file.&quot;

[[std.capabilities.&quot;wasi:filesystem&quot;.allow]]
path = &quot;**&quot;           # glob — &quot;**&quot; means any path
mode = &quot;rw&quot;           # &quot;ro&quot; or &quot;rw&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If it needs outbound HTTP:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-toml&quot;&gt;[std.capabilities.&quot;wasi:http&quot;]
description = &quot;Fetches OpenAPI specs from public catalogs.&quot;

[[std.capabilities.&quot;wasi:http&quot;.allow]]
host = &quot;petstore3.swagger.io&quot;   # &quot;*&quot; = any, &quot;*.suffix&quot; = suffix, else exact
scheme = &quot;https&quot;                # optional
methods = [&quot;GET&quot;]               # optional
ports = [443]                   # optional
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;act-build pack&lt;/code&gt; validates these at build time and embeds them in the
&lt;code&gt;act:component&lt;/code&gt; custom section. &lt;code&gt;act-build validate&lt;/code&gt; re-parses at
any point in the supply chain. A component with a missing declaration
— or one that declares the capability table but leaves &lt;code&gt;allow&lt;/code&gt; empty
— is hard-deny at host-load time, full stop. There&apos;s no way to &quot;oops,
I forgot to declare&quot; yourself into ambient access.&lt;/p&gt;
&lt;h2&gt;Operator policy is the other half&lt;/h2&gt;
&lt;p&gt;Separately, the operator specifies what they&apos;ll grant:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;act run &amp;lt;component&amp;gt; \
  --fs-policy allowlist \
  --fs-allow &quot;/data/**&quot; \
  --fs-allow &quot;/tmp/work/db.sqlite&quot; \
  --http-policy allowlist \
  --http-allow &quot;host=api.example.com;scheme=https&quot; \
  --http-deny &quot;cidr=10.0.0.0/8&quot; \
  --http-deny &quot;cidr=169.254.169.254/32&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Or packaged as a profile in &lt;code&gt;~/.config/act/config.toml&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-toml&quot;&gt;[profile.sqlite-dev.policy]
fs = { mode = &quot;allowlist&quot;, allow = [
  { path = &quot;/Users/me/dev.sqlite&quot;, mode = &quot;rw&quot; },
]}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This is the operator&apos;s intent, not the component&apos;s. It can be as
liberal or paranoid as you like.&lt;/p&gt;
&lt;h2&gt;The effective policy is the intersection&lt;/h2&gt;
&lt;p&gt;The host computes &lt;code&gt;user ∩ declaration&lt;/code&gt; at component load. Concretely,
in the runtime code:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-rust&quot;&gt;// runtime/effective.rs
pub fn effective_fs(
    user: &amp;amp;FsConfig,
    declared: &amp;amp;[FilesystemAllow],
) -&amp;gt; FsConfig { … }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Every operator &lt;code&gt;--fs-allow&lt;/code&gt; entry is checked against the declared
ceiling; entries that fall outside the ceiling are silently dropped.
Symmetrically, a declaration alone doesn&apos;t grant anything — the
operator still has to opt in.&lt;/p&gt;
&lt;p&gt;This model has two nice properties:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A &lt;strong&gt;permissive operator&lt;/strong&gt; (say, &lt;code&gt;--fs-policy open&lt;/code&gt;) still can&apos;t
let a component read files outside what it declared. The ceiling
stops them.&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;lazy component author&lt;/strong&gt; can&apos;t silently reach outside the
operator&apos;s policy. The WASI layer&apos;s capability imports come from
the host; the host refuses to wire up more than the operator
authorized.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;DNS-layer deny&lt;/h2&gt;
&lt;p&gt;HTTP policy is the more interesting half because redirects, CIDR
rules, and DNS all interact.&lt;/p&gt;
&lt;p&gt;The &lt;a href=&quot;https://docs.rs/reqwest&quot;&gt;&lt;code&gt;reqwest&lt;/code&gt;&lt;/a&gt;-backed HTTP client that ACT
uses has a &lt;strong&gt;custom DNS resolver&lt;/strong&gt; that sits in front of every
outbound request. After a name resolves, every resolved IP
is checked against the operator&apos;s &lt;code&gt;--http-deny cidr=…&lt;/code&gt; rules
&lt;strong&gt;before&lt;/strong&gt; the client proceeds to connect.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;reqwest → PolicyDnsResolver
           ├── resolve(&quot;api.example.com&quot;)
           │    → [1.2.3.4, 5.6.7.8]
           ├── check each IP vs deny-CIDRs
           ├── check each IP vs allow-CIDRs
           └── if none survives: DnsError
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A component that tries to phone home to &lt;code&gt;169.254.169.254&lt;/code&gt; (the
cloud-metadata service IP) doesn&apos;t get a &quot;connection refused&quot; —
it gets a &lt;code&gt;DnsError&lt;/code&gt;, before the socket is ever opened. That&apos;s a
deliberate choice: attackers can differentiate connection-refused
from DNS-not-resolved, and we want the failure indistinguishable
from the name never existing.&lt;/p&gt;
&lt;h2&gt;Per-hop redirect re-check&lt;/h2&gt;
&lt;p&gt;Every hop of an HTTP redirect chain is re-checked against the same
policy. A 302 to a denied host fails mid-chain instead of quietly
succeeding. The client uses a custom &lt;code&gt;redirect::Policy&lt;/code&gt; that invokes
the same &lt;code&gt;network::decide&lt;/code&gt; function used for the initial request:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-rust&quot;&gt;// runtime/http_client.rs
fn build_redirect_policy(
    cfg: HttpConfig, declared: Vec&amp;lt;HttpAllow&amp;gt;
) -&amp;gt; reqwest::redirect::Policy {
    reqwest::redirect::Policy::custom(move |attempt| {
        match decide(&amp;amp;cfg, &amp;amp;declared, attempt.url()) {
            Decision::Allow =&amp;gt; attempt.follow(),
            Decision::Deny(_) =&amp;gt; attempt.stop(),
            …
        }
    })
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This closes the redirect-smuggling bypass that naive host-list
filters fall into.&lt;/p&gt;
&lt;h2&gt;Ancestor traversal, a practical detail&lt;/h2&gt;
&lt;p&gt;WASI path resolution stats every intermediate directory when opening
a nested file. The first cut of the policy bit us with a real
component on this: an &lt;code&gt;--fs-allow /tmp/work/db.sqlite&lt;/code&gt; entry failed
to open the file because WASI needed to stat &lt;code&gt;/tmp/work&lt;/code&gt; and &lt;code&gt;/tmp&lt;/code&gt;
first, and neither was explicitly allowed.&lt;/p&gt;
&lt;p&gt;The fix: an allow entry for &lt;code&gt;/tmp/work/db.sqlite&lt;/code&gt; now implicitly
permits &lt;code&gt;/tmp/work&lt;/code&gt; and &lt;code&gt;/tmp&lt;/code&gt; for directory traversal, while sibling
files in those directories remain denied. The implementation walks
&lt;code&gt;target.ancestors()&lt;/code&gt; during policy check:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-rust&quot;&gt;// runtime/fs_matcher.rs
if self.allow_prefixes.iter().any(|prefix| is_ancestor(path, prefix)) {
    return FsDecision::Allow;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No more &quot;list every parent directory&quot; dance. If you allow a leaf,
you get traversal to it for free.&lt;/p&gt;
&lt;h2&gt;What this buys us&lt;/h2&gt;
&lt;p&gt;All together: the component author states intent at build time, the
operator states grants at run time, the host computes the
intersection, the WASI imports are filtered accordingly, the HTTP
client re-checks each redirect hop, and the DNS resolver filters IPs
before a socket opens.&lt;/p&gt;
&lt;p&gt;It&apos;s not &quot;a sandbox&quot;. It&apos;s a VM plus an explicit, auditable
capability pipeline. A tool from a stranger — &lt;code&gt;ghcr.io/somebody/…&lt;/code&gt;
— is safe to point your agent at in a way that &lt;code&gt;npm install -g&lt;/code&gt; has
never been.&lt;/p&gt;
&lt;h2&gt;Where this fits&lt;/h2&gt;
&lt;p&gt;Sandboxing is the floor. On top of it, stateful capabilities
(sessions, events, resources) get the same treatment — declared at
build time, granted at run time, intersected by the host. The
&lt;a href=&quot;https://actcore.dev/blog/2026-05-07-act-07-sessions/&quot;&gt;sessions and bridges post&lt;/a&gt; walks
through that next layer, including how authentication lives inside
session args (validated against a typed JSON Schema) rather than
floating through per-call metadata.&lt;/p&gt;
&lt;p&gt;Still pending:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Per-op filesystem gating under wasip3 — currently awaiting upstream
&lt;code&gt;wasmtime-wasi&lt;/code&gt; API.&lt;/li&gt;
&lt;li&gt;A distribution post: OCI registries, signed SBOMs, reproducible
builds, and what &lt;a href=&quot;https://actpkg.dev&quot;&gt;actpkg.dev&lt;/a&gt; will ship.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Questions welcome in &lt;a href=&quot;https://github.com/actcore/act-spec/discussions&quot;&gt;Discussions&lt;/a&gt;.&lt;/p&gt;
</content:encoded><author>actcore</author></item><item><title>MCP servers, sandboxed — introducing ACT</title><link>https://actcore.dev/blog/2026-04-23-introducing-act/</link><guid isPermaLink="true">https://actcore.dev/blog/2026-04-23-introducing-act/</guid><description>Today&apos;s MCP servers ship as `npx`, `uvx`, or `curl | bash` — ambient-permission native processes with your full user access. ACT packages tools as sandboxed WebAssembly components with declared capabilities and deny-by-default filesystem and network, so an agent can safely call tools written by a stranger.</description><pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; ACT-HTTP — the REST binding with &lt;code&gt;/info&lt;/code&gt;, &lt;code&gt;/tools&lt;/code&gt; and
&lt;code&gt;/sessions&lt;/code&gt; — was removed in &lt;code&gt;act&lt;/code&gt; 0.12.0. MCP is now ACT&apos;s transport on the wire:
use &lt;code&gt;--mcp&lt;/code&gt; for stdio or &lt;code&gt;--mcp --http&lt;/code&gt; for MCP over Streamable HTTP at &lt;code&gt;/mcp&lt;/code&gt;.
The commands below that use &lt;code&gt;act run --http&lt;/code&gt; no longer work as written; everything
about sessions and components themselves still holds. See
&lt;a href=&quot;https://actcore.dev/docs/host/transports/&quot;&gt;Transports&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Update (2026-08):&lt;/strong&gt; the per-class policy flags used below — &lt;code&gt;--fs-policy&lt;/code&gt;,
&lt;code&gt;--fs-allow&lt;/code&gt;, &lt;code&gt;--http-policy&lt;/code&gt;, &lt;code&gt;--http-allow&lt;/code&gt; and friends — were replaced by a uniform
grant model (&lt;code&gt;--grant&lt;/code&gt;, &lt;code&gt;--allow&lt;/code&gt;, &lt;code&gt;--deny&lt;/code&gt;), and the default mode is now &lt;code&gt;ask&lt;/code&gt; rather
than deny. The capability-ceiling model this post describes is unchanged; only the flag
spelling is. See &lt;a href=&quot;https://actcore.dev/docs/host/policy/&quot;&gt;Policy &amp;amp; sandbox&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Setting up an MCP server for your AI agent today usually looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;npx -y @some-org/mcp-server          # or
uvx some-mcp-server                  # or the occasional
curl https://example.com/install.sh | bash
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The server runs as you. It can read your home directory. It sees your SSH keys, your &lt;code&gt;.env&lt;/code&gt; files, your shell history, your browser cookies, your GPG keyring. If the server has a bug — or a malicious dependency sneaks in — the code that reads those files also runs as you. If your kernel or any installed binary has an unpatched local privilege escalation, the agent-invoked tool just inherited that escalation path too.&lt;/p&gt;
&lt;p&gt;That isn&apos;t a failure mode of any particular MCP server; it&apos;s the default deployment model. &lt;strong&gt;Ambient-permission native processes, shipped by anyone, invoked on demand by an LLM that&apos;s notoriously easy to talk into misusing them.&lt;/strong&gt; &quot;Your agent has your credentials and runs strangers&apos; code on request&quot; is the baseline security posture of every MCP setup built on &lt;code&gt;npx&lt;/code&gt; / &lt;code&gt;uvx&lt;/code&gt; / &lt;code&gt;curl | bash&lt;/code&gt; today. It&apos;s a full-blown security nightmare that the industry has collectively decided not to look at.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT&lt;/strong&gt; — Agent Component Tools — is the model that looks at it.&lt;/p&gt;
&lt;p&gt;Every ACT tool is a WebAssembly component running inside &lt;a href=&quot;https://wasmtime.dev&quot;&gt;&lt;code&gt;wasmtime&lt;/code&gt;&lt;/a&gt; — a full VM with a JIT, linear memory, and no ambient host syscalls. Out of the box the component has zero filesystem access, zero outbound network, and no way to spawn a process. Each capability it does use (&lt;code&gt;wasi:filesystem&lt;/code&gt;, &lt;code&gt;wasi:http&lt;/code&gt;) is &lt;strong&gt;declared&lt;/strong&gt; in the component manifest at build time and &lt;strong&gt;granted&lt;/strong&gt; by the operator at run time. The host enforces the intersection: a permissive operator can&apos;t escalate past the component&apos;s stated intent, a lazy component can&apos;t silently exceed the operator&apos;s grant. You hand a tool from &lt;code&gt;ghcr.io/someone-else/whatever&lt;/code&gt; to your agent, and the worst-case blast radius is still bounded by the policy you wrote.&lt;/p&gt;
&lt;p&gt;That&apos;s the core trade ACT offers. The rest of this post is about why the WebAssembly-component substrate makes it practical.&lt;/p&gt;
&lt;h2&gt;Distribution, for free&lt;/h2&gt;
&lt;p&gt;A side benefit of picking WebAssembly: the artifact is a single binary that runs everywhere.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;act info actpkg.dev/library/random:latest --tools
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;That command pulls a small component from GitHub&apos;s container registry, reads its metadata from a WASM custom section (no instantiation), and prints the tools it exposes. First pull is cached, every subsequent invocation hits the local &lt;code&gt;~/.cache/act/components&lt;/code&gt;. The artifact is signed by GitHub&apos;s attestation workflow and comes with an SBOM — all upstream machinery; ACT just uses it.&lt;/p&gt;
&lt;p&gt;Same bytes, same SHA256, on Linux x86_64, macOS arm64, Windows, Android (validated), Raspberry Pi, inside a browser tab, inside a serverless runtime. No per-platform wheels, no native shims, no build toolchain required on anyone&apos;s machine but yours. And because the artifact is a registry object rather than three separate npm/pip/cargo packages, there&apos;s one supply-chain path to audit instead of three.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;act&lt;/code&gt; accepts components from any of:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;local path: &lt;code&gt;./my-component.wasm&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;HTTP URL: &lt;code&gt;https://example.com/tool.wasm&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;OCI ref: &lt;code&gt;ghcr.io/your-org/tool:1.2.3&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;No &quot;my-tool-npm&quot; and &quot;my-tool-pypi&quot; and &quot;my-tool-cargo&quot;. One artifact. One namespace.&lt;/p&gt;
&lt;h2&gt;How the sandbox actually works&lt;/h2&gt;
&lt;p&gt;The isolation comes from three stacked layers, and it&apos;s worth separating them because &quot;WASI sandbox&quot; isn&apos;t quite the right phrase.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;wasmtime&lt;/strong&gt; is the actual isolation. It&apos;s a WebAssembly VM: linear-memory bounds enforced, no direct syscalls, no pointer aliasing, no escape outside of explicit host imports. Every ACT target runs the same wasmtime, so the isolation is identical on every OS and CPU.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;WASI&lt;/strong&gt; is the capability-import layer on top. A component asks for &lt;code&gt;wasi:filesystem&lt;/code&gt; or &lt;code&gt;wasi:http&lt;/code&gt; imports; the host either wires them up, provides a gated proxy, or leaves them unlinked. There&apos;s no &quot;deny&quot; at the capability level — a component either has the import or it doesn&apos;t.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ACT&lt;/strong&gt; is the policy layer on top of WASI. Filesystem and outbound network are deny-by-default. The component&apos;s manifest declares what it needs (&lt;code&gt;[std.capabilities.&quot;wasi:filesystem&quot;]&lt;/code&gt;, &lt;code&gt;&quot;wasi:http&quot;&lt;/code&gt;) — this is a ceiling. The operator&apos;s runtime flags (&lt;code&gt;--fs-allow /tmp/db.sqlite&lt;/code&gt;, &lt;code&gt;--http-allow host=api.example.com&lt;/code&gt;) are the grant. The host computes the intersection and refuses to wire up anything outside it.&lt;/p&gt;
&lt;p&gt;Deny-CIDR rules sit in front of DNS resolution, so a component that tries to reach &lt;code&gt;169.254.169.254&lt;/code&gt; (the cloud-metadata service) fails with a &lt;code&gt;DnsError&lt;/code&gt; before a socket opens. HTTP redirects are re-checked per-hop, so a 302 to a denied host fails mid-chain instead of quietly succeeding. Details are in the &lt;a href=&quot;https://actcore.dev/blog/&quot;&gt;capability-layer deep-dive&lt;/a&gt; (next post).&lt;/p&gt;
&lt;p&gt;The VM gives us isolation. WASI gives us capability imports. ACT gives us the declaration-plus-ceiling model that makes those capabilities safe to hand to third-party code.&lt;/p&gt;
&lt;h2&gt;One component, any transport&lt;/h2&gt;
&lt;p&gt;Because tools are components, not native processes, the host can serve them over whatever wire format the caller wants.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;# Claude Desktop / Cursor / Cline → stdio JSON-RPC
act run actpkg.dev/library/sqlite:latest --mcp \
  --fs-policy allowlist --fs-allow /tmp/demo.sqlite

# Web backend → REST-ish HTTP with SSE streaming
act run actpkg.dev/library/sqlite:latest --http --listen &quot;[::1]:3000&quot;

# Script / CI → one-shot direct call
act call actpkg.dev/library/sqlite:latest query \
  --args &apos;{&quot;sql&quot;: &quot;SELECT sqlite_version()&quot;}&apos; \
  --metadata &apos;{&quot;database_path&quot;:&quot;/tmp/demo.sqlite&quot;}&apos;

# Browser tab → jco transpile, no server at all
jco transpile actpkg.dev/library/sqlite:latest -o dist/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Same component, same tool, four deployments. Whatever new transport shows up next, the component doesn&apos;t change.&lt;/p&gt;
&lt;h2&gt;Writing one&lt;/h2&gt;
&lt;p&gt;Rust, the whole SDK surface for a trivial tool:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-rust&quot;&gt;use act_sdk::prelude::*;

#[act_component]
mod component {
    use super::*;

    #[act_tool(description = &quot;Reverse a string&quot;, read_only)]
    fn reverse(text: String) -&amp;gt; ActResult&amp;lt;String&amp;gt; {
        Ok(text.chars().rev().collect())
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;cargo build --target wasm32-wasip2 --release&lt;/code&gt; + &lt;code&gt;act-build pack&lt;/code&gt; and you have a &lt;code&gt;.wasm&lt;/code&gt; that speaks MCP, HTTP, and the CLI. &lt;code&gt;#[act_tool]&lt;/code&gt; derives the JSON Schema from the function signature; &lt;code&gt;#[act_component]&lt;/code&gt; emits the WIT export. Python has the same shape with &lt;code&gt;@component&lt;/code&gt; / &lt;code&gt;@tool&lt;/code&gt; decorators on top of &lt;a href=&quot;https://github.com/bytecodealliance/componentize-py&quot;&gt;&lt;code&gt;componentize-py&lt;/code&gt;&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Where this is&lt;/h2&gt;
&lt;p&gt;Early, and deliberately narrow.&lt;/p&gt;
&lt;p&gt;The core spec lives in &lt;a href=&quot;https://github.com/actcore/act-spec&quot;&gt;actcore/act-spec&lt;/a&gt; — a small WIT package for cross-cutting types and an opt-in interface package for tool dispatch, with stateful capabilities (sessions, events, resources) layered on as separate opt-in packages. The host ships as &lt;code&gt;act&lt;/code&gt; on npm, cargo, and PyPI. A growing set of components is published on &lt;a href=&quot;https://actpkg.dev&quot;&gt;&lt;code&gt;actpkg.dev/library&lt;/code&gt;&lt;/a&gt; — &lt;code&gt;sqlite&lt;/code&gt;, &lt;code&gt;http-client&lt;/code&gt;, &lt;code&gt;crypto&lt;/code&gt;, &lt;code&gt;encoding&lt;/code&gt;, &lt;code&gt;filesystem&lt;/code&gt;, &lt;code&gt;openwallet&lt;/code&gt;, &lt;code&gt;python-eval&lt;/code&gt;, &lt;code&gt;js-eval&lt;/code&gt;, &lt;code&gt;random&lt;/code&gt;, &lt;code&gt;time&lt;/code&gt;, plus three bridges (&lt;code&gt;mcp-bridge&lt;/code&gt;, &lt;code&gt;openapi-bridge&lt;/code&gt;, &lt;code&gt;act-http-bridge&lt;/code&gt;). Rust and Python SDKs are live; JavaScript via &lt;code&gt;componentize-js&lt;/code&gt; is &lt;a href=&quot;https://github.com/bytecodealliance/ComponentizeJS/issues/335&quot;&gt;blocked on upstream async-export support&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;More on the architecture:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://actcore.dev/blog/2026-04-24-capability-ceiling/&quot;&gt;The capability ceiling&lt;/a&gt; — declaration-as-ceiling, DNS-level deny-CIDR, per-hop redirect re-check, ancestor traversal, and what goes wrong when any of those is missing.&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://actcore.dev/blog/2026-05-07-act-07-sessions/&quot;&gt;Sessions and bridges&lt;/a&gt; — how stateful components (databases, OpenAPI clients, MCP-server proxies) own their per-session state and where authentication actually belongs.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If you write MCP servers, build agent tooling, or work on the component model, we&apos;d love your thoughts. Start at &lt;a href=&quot;https://actcore.dev/docs/&quot;&gt;actcore.dev/docs&lt;/a&gt;, browse &lt;a href=&quot;https://github.com/actcore&quot;&gt;github.com/actcore&lt;/a&gt;, or open a thread in &lt;a href=&quot;https://github.com/actcore/act-spec/discussions&quot;&gt;Discussions&lt;/a&gt;.&lt;/p&gt;
</content:encoded><author>actcore</author></item></channel></rss>