A FHIR search can succeed even when the server ignored your filter.
FHIR is the standard many healthcare systems use to exchange data. Under the R4 search spec, servers should generally ignore unknown or unsupported parameters, and the request can still succeed. The spec also requires servers to report the parameters they actually used in the response’s "self" link, and requires applications to check them where necessary.
Say an agent is asked to summarize a patient’s labs from October. If the server ignored the date filter, August and September results could come back too. An agent that trusts the retrieval could summarize them as October labs.
Check the self link before the results reach the agent. If a required filter is missing, stop the summary and report the retrieval problem. You can send "Prefer: handling=strict" to ask the server to reject unsupported parameters, but servers aren’t required to honor it. Compare the filters and values reported in the self link with the intended query, and test the endpoint’s behavior.
This matters more when the agent builds the query. A misspelled parameter name can be ignored too.
To test it, use a synthetic patient with labs inside and outside the window. Confirm the integration returns the expected set, including later pages. Add a stubbed response where the date filter is missing from the self link, and confirm the summary stops. Keep these cases in the integration tests as the endpoint changes.
We’ve published a free, open-source interactive guide to US health insurance for engineers, product teams and founders building software and agents in healthcare.
Follow Maya through a fictional plan year. Move her MRI from March to November and see why her share of the same $1,000 claim drops from $1,000 to $200. Watch the claim from the provider’s side, through the plan’s adjudication, to the payment landing in the right account.
The guide maps nine places where software attaches to these workflows, from eligibility and prior authorization to remittance and reconciliation. For each one: who buys it, what they measure, the standard it runs on and the rule behind it.
A billing agent's ROI depends on whose costs you count.
The Peterson Health Technology Institute (PHTI), in its administrative AI workshop summary updated October 15, describes a problem for healthcare builders: provider automation can increase billing intensity and spending, while health plans respond by reducing reimbursement. These are findings from a workshop with industry leaders, rather than a controlled test of a particular product.
For a team evaluating a billing workflow, we'd keep the measures separate:
• Staff time spent preparing and reviewing each claim, including corrections.
• The provider's payment received and time to payment.
• The payer's review effort and amount paid.
• The patient's eventual responsibility and any work needed to resolve errors.
A larger payment to the provider changes who receives the money. It doesn't, by itself, establish that the workflow used fewer resources. Minutes saved in preparation can also disappear in downstream review.
Before a pilot, define the unit of work and follow the same claims through corrections and payment. Keep human review time in the calculation. That gives the team a way to see where the benefit lands and whether work has simply moved to someone else.
A prior authorization response can say "complete" while the authorization is still pending.
HL7’s Da Vinci Prior Authorization Support (PAS) guide defines how healthcare systems exchange authorization requests and responses. Its example contains exactly that combination. ClaimResponse.outcome is "complete", and the service item’s review action is A4, "Pending". The first field describes processing. The second carries the authorization decision for that item.
For a healthcare agent, this affects what it can tell the person waiting for care. Turning "complete" into "your authorization was approved" would misrepresent the payer’s response.
Keep processing status separate from each service item’s decision in the application. Give the agent those fields explicitly. Use this example as a regression case. The workflow should remain pending, and the agent’s explanation should preserve that status. An absent or unrecognized decision should go to an exception path for review.
Our US health insurance guide follows a scheduled MRI through eligibility, prior authorization, care and claims.
https://t.co/s1tCt0xxN3
History rhymes. We lived through UML and Rational Rose, SOAP and integration middleware, and maturity models. Now it’s AI development processes, agent frameworks, and another round of maturity models.
Beware the merchants of complexity. Every additional layer is something a team has to understand, operate and eventually change. Open standards are the exception worth paying for. W3C gave the web a shared foundation; AI needs the same, because rebuilding identical integrations inside every vendor’s ecosystem helps nobody.
We’re mid-transition, still finding out which abstractions help, which practices hold up and where the boundaries belong. Models, agents and harnesses all need room to experiment and revise.
Every layer should earn its place.
We started building JavaFlat, an experiment in compiling modern Java syntax to native code through MLIR, with no garbage collector.
The goal is to check ownership at compile time while keeping familiar Java syntax. We’re starting with the ownership checker. It’s early and mostly design work so far.
One of our engineers was looking at the Pizza Bot announcement and immediately noticed that the divider under 'Activity' doesn’t line up with the main panel. Now I can’t unsee it.
I love working with engineers and designers who notice these things and care about how the whole interface comes together.
We’re continually reviewing and refining our own interfaces, including Sail. There’s always something to improve. Pizza Bot is open source, so she will try to open a PR for this one over the weekend.
We gave Light's superconnector agent a @java REPL. Its job is to find useful connections between community members, including people with complementary skills, shared interests or a reason to collaborate across different fields.
We use JShell so the agent can write Java snippets, retain variables between calls and compose operations over the candidates it finds. Java generates a deterministic search-coverage plan from a member's needs, skills, interests and values. The code defines the combinations to consider. The agent turns that plan into semantic queries grounded in the member's work and goals. We ask it to vary phrasing and specificity, search from the other person's perspective, and explore adjacent fields. The coverage plan is repeatable for the same inputs. The generated queries can vary.
Across multiple top-k searches, the working set can accumulate hundreds of candidates. The REPL lets the agent compute over that pool without keeping every full profile in its conversational context. Java compares and scores the stored records, and we ask the agent to score the full pool before choosing finalists. Hooks check search counts for each matching hypothesis and flag final IDs missing from the working set for correction. This helps mitigate hallucinated candidate references. The agent still uses judgment for the mix of connections and close decisions.
The scoring keeps two directions explicit: how someone's capabilities meet your needs, and how yours meet theirs. Those components are returned with the ranking, so we can inspect whether a proposed connection has value in one direction or both. A high similarity score alone doesn't tell us that.
When we upgrade Sail, the multi-agent harness, the shell running inside a project's Incus container should still be there afterward. That gets interesting when the service being replaced owns the terminal connection.
Our solution was to build a small PTY session host for Sail. A PTY is the operating-system interface that lets a program behave as though it has an interactive terminal. Closing its master descriptor can hang up the session, so keeping some terminal text on disk would only solve part of the problem. On hosts configured for this handoff, Sail passes the master descriptors to systemd's file descriptor store. Systemd keeps them open while the old service exits. The replacement service adopts them and reconnects the session to its saved metadata and bounded output history. The shell inside the container keeps running.
Our @java implementation uses Panama/FFM to call sendmsg and pass descriptors with SCM_RIGHTS. We also have a small protocol for attaching clients and carrying terminal input and output. Process survival depends on the descriptor handoff and service lifecycle. There is no tmux in this path.
It's been fun addressing these challenges as we continue to use Sail as the daily driver for our engineers.
We're getting close to v1 of Sail, the open source software factory we've been building and using at @standardapplied. Sail coordinates work across coding agents and engineers, with an isolated Incus environment for each project.
A few interesting parts:
• Multiple agent harnesses: Sail supports coding agents like Claude Code and Codex, including having one review the other’s work. Specs get dispatched and move through a loop with review and validation stages.
• Slack-like rooms around the work: Agents can post progress and flag questions that need a person. Other engineers can follow the conversation and chime in. Human replies reach a running agent between tool calls, so the discussion can inform the work already underway.
• A distributed control plane: Each engineer's node synchronizes with the main node. Specs, room conversations, runs and reviews travel between them, while a spec executes on its assignee's node. Shared work stays visible across the team, with explicit conflicts when edits need reconciliation.
• Terminals that survive Sail upgrades: We built a small PTY protocol and session host. On hosts configured for descriptor handoff, systemd holds the PTY master descriptors while the service restarts. The new service adopts them, preserving the shell inside the Incus container and its retained output history. No tmux involved.
• Terminal UI: We used Ghostty's libghostty-vt compiled to WebAssembly for terminal parsing and state, with our own rendering layer. It connects to Sail's host-owned sessions over SSH.
Sail is written in @java 25 and compiled as a @graalvm native image. Panama/FFM lets us call the native PTY and descriptor-passing APIs directly from Java. Over the coming weeks, we’ll share how we keep terminal sessions alive through upgrades, what we learned using FFM, and how we built the desktop/mobile apps with Rust and @TauriApps.
A few months ago, we built an AI-assisted onboarding flow for our partner, Light. People can create their profiles through Mad Libs style prompts or write in free form.
Gemini Flash generates suggestions for the blanks in the guided flow. For freeform answers, it extracts short phrases into profile fields covering attributes like skills and what someone is looking for. The source of an answer matters. Someone writing “I'm looking for a fundraising mentor” is telling us what they need. Putting fundraising under their skills would misrepresent them. Ofc, we pass the source field along with the text so the model has that context. The onboarding calls already request a low thinking level and return typed outputs. When several free-form fields need extraction, their calls run concurrently. Fields left blank skip extraction entirely.
The next piece we'd like to evaluate is a classifier that checks whether each extracted attribute is supported by what the person wrote. It would return a defined answer: supported, contradicted or insufficient evidence.
@typesafeai's Jev supports this kind of classification through typed questions and predefined choices. I'd like to test whether OSS models like @googlegemma can handle that role for our onboarding flow, using constrained outputs. We'd compare the current extraction on its own with versions that add a Gemma check. The evals would use human-reviewed examples, including ambiguous answers and people describing both what they offer and what they need. We'd measure unsupported attributes that slip through and valid ones that get rejected, alongside the added latency and cost per completed profile.
The stack is our beloved @java, @graalvm and Helios (which provides the agentic building blocks, tracing and prompt management we use to build evaluation workflows).
After a long hike, I was getting ready for a movie night with friends. We were too tired to keep debating what to watch, so I decided to try @typesafeai's Jev with computer use to browse and navigate @netflix. Apparently I still had enough energy for an experiment.
Our tastes were spread across action/thrillers, sci-fi set in space, and romance. I gave Jev descriptions from a small Netflix shortlist and asked it to assess each person's preferences. We allowed a two-out-of-three compromise, with the unmatched preference kept explicit.
It picked I.S.S. for the action and space fans. Then I checked the ratings: 5.3 on IMDb and 43% from Rotten Tomatoes audiences. I'd spent all that effort matching genres and left audience ratings out of the criteria.
For the rerun, I added minimums of 6.5 on IMDb and 60% from RT audiences, keeping critics' scores separate. I expanded the shortlist and supplied fuller plot descriptions. Jev assessed the genre and plot evidence; the application checked the rating cutoffs and counted how many people matched.
The latest run picked The Adam Project (2022): IMDb 6.7, Tomatometer 68% (critics), and Popcornmeter 73% (audience). Jev counted the action and romantic storyline toward our two-of-three rule. It is a time-travel adventure with a secondary love story, so the space fan would be compromising.
There's more to evaluate. We just worked through a small shortlist. I'd like streaming services to offer a "movie night picker." A profile captures one person's habits. When three to five people share a screen, the recommendation should account for who's watching together and what each person is willing to compromise on.
Mast's terminal runs on libghostty-vt, Ghostty's terminal core, which they ship as a standalone WASM build. We wrote the bindings and our own WebGPU renderer on top. libghostty is a thing of beauty.
The terminals themselves live server-side as durable pty sessions inside each project's (Incus) container. Reattach from your desk or your phone, land in the same shell. Sessions belong to rooms, so the terminal where you brainstormed with Claude sits next to the conversation and the specs it produced.
We built this for one job: senior engineers running a software factory, dispatching coding agents and dropping into a real shell beside them when it matters.
Everyone's out here talking Rust, Zig, Bun... Meanwhile half the Fortune 500 quietly runs on @java. And JDK 26 is genuinely fantastic and boringly reliable.
Make Java Great Again. Ship the JAR, wear the hat 🧢
Bun with Electronbun is fun to use for building desktop apps. The RPC feature needs some work, but overall the DX has been amazing!
Our software factory app is taking shape.
A new HIPAA rule means every vendor contract a hospital signed under the old one might be out of date. Could be thousands of them.
We built a tool that reads all of them and writes the fixes. Here is 40 seconds.
@googlegemma@Cerebras