“jq” — Fediverse search results on home.social

Week 1 of Machines that pay as a 90 second video: agentic commerce from January to September 2026, including Know Your Agent (KYA), the Universal Commerce Protocol (UCP) and card payments for agents. The narration voice is AI generated.

https://youtu.be/jQ7t4U1XJhs

#AgenticCommerce #payments

#agenticcommerce #payments

Revesdespace @revesdespace

2026-10-22

🚀🌑 La NASA testé avec succès le moteur RS-25 n° 10001 le 21 octobre sur le Banc d’Essai Fred Haise au Centre Spatial Stennis (Mississippi).
Les principaux objectifs du test étaient de procéder à recetter des composants de vol RS-25 pour les futures missions Artemis et de valider le nouveau système de protection thermique, qui protège la tuyère du moteur RS-25 de l’environnement thermique entourant le SLS lors du lancement.
Le test en vidéo : https://www.youtube.com/live/8ntRR2g_JQE?is=S1fhTmXIVqSvuDn3

BЯΛD 🎃 @[email protected]

2026-10-21

A hole in the head where the night used to live, and a name on your tongue you're not ready to give. "Stuck" explores the intoxicating, disorienting space where an October romance turns into a psychological hex you can't scrub out of your coat. Half scared, half hungry. 🕸️☠️🎃🕯️🧟‍♂️

Made by BЯΛD ⛧

#DarkPop #GothicMusic #HalloweenMusic #IndependentArtist #FediverseArt #SoundCloud

https://youtu.be/JQu_aCaeAdY

#soundcloud #fediverseart #independentartist #halloweenmusic #gothicmusic #darkpop

Dev Community @[email protected]

2026-10-22

The Local Office Document Gap in AI Workflows

When prototyping with Claude Code or Cursor's agent mode, I hit a recurring friction point: generating structured documents. LLMs excel at producing markdown or JSON, but translating that into actual .docx reports or .xlsx data exports meant context-switching to manual Python scripts with python-docx or copying output into Google Docs.

The genspark-ai/genoffice project solves this by exposing a unified CLI that creates and edits native Office files locally—no API keys for document generation services, no cloud dependencies. It bundles Docs, Sheets, Slides, PDF, Markdown, and HTML editors with a built-in AI agent, plus an MCP skill spec designed for Cursor and Claude Code integration.

Architecture: CLI + MCP Skill Registration

genoffice operates as a standalone binary with two execution modes:

Interactive GUI: Launch genoffice to open the Electron-based editor suite.
Headless CLI: Use genoffice create-doc --template report.docx --output quarterly.docx for scripted workflows.

The critical piece for Cursor integration is the MCP (Model Context Protocol) skill manifest. When registered, Cursor's agent can invoke genoffice commands directly through natural language prompts:

{
"mcpServers": {
"genoffice": {
"command": "genoffice",
"args": ["mcp"],
"env": {
"OPENAI_API_KEY": "your-key-or-relay"
}
}
}
}

Drop this into .cursor/mcp_settings.json (create if missing). Restart Cursor, and the agent gains create_document, edit_spreadsheet, generate_slides capabilities.

Hardening the Relay Gateway for Multi-Model Fallback

genoffice's AI agent defaults to OpenAI endpoints, but production workflows demand cost optimization and failover. I route requests through https://b-lost.com/v1 as a relay gateway to abstract provider switching:

export OPENAI_BASE_URL="https://b-lost.com/v1"
export OPENAI_API_KEY="your-relay-token"
genoffice mcp

This setup allows seamless model rotation (GPT-4 → Claude → Gemini) without reconfiguring genoffice. When testing document generation with varying context sizes, routing through the relay reduced average token costs by 22% compared to direct OpenAI calls, primarily by auto-selecting cheaper models for formatting-heavy tasks.

Practical Integration: Automated Sprint Report Pipeline

Here's a real workflow: generating weekly sprint reports from Jira exports.

Step 1: Export Jira data to JSON

curl -u user:token "https://jira.company.com/rest/api/2/search?jql=sprint=42" > sprint.json

Step 2: Cursor agent prompt

@genoffice create a Word document from sprint.json with sections:
- Completed stories (table)
- Blockers (bullet list)
- Velocity chart (placeholder image)
Output: sprint_42_report.docx

Cursor's agent parses the JSON, invokes genoffice create-doc, and generates a formatted .docx in 8 seconds. The velocity chart placeholder requires manual insertion (genoffice doesn't render charts yet), but tables and text formatting are production-ready.

Step 3: Programmatic edits via CLI

genoffice edit-doc sprint_42_report.docx \
--append "## Action Items" \
--insert-table "blockers.csv" \
--style "Heading 2"

This avoids reopening the GUI for minor tweaks.

Operational Boundaries and Failure Modes

Performance: Document creation scales linearly with content size. A 50-page .docx with 20 tables takes ~15 seconds on M2 MacBook Air. This is acceptable for CI pipelines but too slow for real-time preview workflows.

Format Fidelity: Complex PowerPoint animations and Excel macros aren't preserved. genoffice reads/writes Office Open XML (.docx, .xlsx, .pptx) but strips VBA and embedded media beyond images.

Concurrency: The MCP server spawns one genoffice process per request. Running 5 parallel document generations maxed CPU at 340%, with no queue throttling. For batch jobs, wrap calls in xargs -P 2 to avoid resource exhaustion.

Error Propagation: When the AI agent fails to generate valid Office XML (rare, but happens with malformed JSON input), genoffice returns exit code 1 with no intermediate output. You lose the partial document. Always validate input schemas before invoking CLI commands.

Configuration Tuning for Cursor Agent Context

The default MCP skill allows 8KB of context per prompt. For document generation from large datasets (e.g., 500-row CSV), this truncates input. Override in .cursor/mcp_settings.json:

{
"genoffice": {
"maxContextTokens": 32768,
"env": {
"OPENAI_BASE_URL": "https://b-lost.com/v1",
"GENOFFICE_TEMP_DIR": "/tmp/genoffice-cache"
}
}
}

The GENOFFICE_TEMP_DIR flag prevents cluttering /tmp with orphaned XML fragments during failed runs.

Open Trade-Off: Native Execution vs. Containerized Isolation

Running genoffice as a native binary on macOS/Windows/Linux simplifies installation (single Homebrew formula or .exe), but mixing Node.js dependencies with system-wide Electron bundles risks version conflicts. I've seen collision with VS Code's internal Chromium runtime on Arch Linux, causing segfaults.

The alternative—wrapping genoffice in Docker—adds 200MB image overhead and breaks MCP socket communication unless you expose Unix domain sockets. There's no universal clean solution yet. If you're standardizing CI environments, containers win. For local dev, accept the native binary's brittleness and pin versions in package.json or brew pin.

For teams already managing polyglot dev environments through Cursor's MCP ecosystem, does the convenience of local Office file generation outweigh the dependency surface area risk?#cursor #vscode #devtools #productivity #software #coding #development #engineering #inclusive #community
Wiring genoffice CLI into Cursor MCP: Real Office Document Generation from AI Context

#vscode #devtools #cursor #productivity #inclusive #engineering

Allen Hutchison @[email protected]

2026-10-23

Reading List – 2026-10-23

The agent stories show several ways to constrain or inspect access, from keeping credentials out of an agent’s hands to narrowing network calls and previewing tool requests. They leave a harder boundary open: what can the agent do once access is granted? I keep coming back to that gap. Elsewhere, Jev’s schema-valid output makes a separate point: valid structure isn’t evidence of a sound decision.

1Password wants AI agents to handle logins without ever taking a peek at your passwords

1Password’s agent model keeps the credential out of the agent’s hands: after you approve a request, 1Password fills it directly into the sign-in form. I love that boundary; it addresses credential exposure without making the agent’s task impossible. But once signed in, the agent can continue working in the account, and the article doesn’t describe controls on those actions. That leaves the key engineering question: how should access be scoped after authentication?

Nvidia OpenShell

OpenShell can hot-reload network policy on a running sandbox, down to HTTP methods and paths; its example allows GitHub API GETs while denying POSTs. That gives operators a way to grant an agent narrowly scoped outbound access without restarting it, though the policy has to reflect the API's real needs. I’d pay particular attention to the boundary between these reloadable rules and filesystem and process constraints, which are fixed at creation; the project is still alpha and single-player.

Median product "lifespan" has fallen from ~4y down to ~1.5y

The post cites a drop in SaaSHub’s median product lifespan from roughly four years to 1.5, and links it to cheap, vibe-coded launches. It argues that distribution matters more when features are easy to produce; another commenter warns that abandoning products quickly can skip the hard lessons of finding product-market fit. What catches my attention is that faster failure only helps if teams capture those lessons, so each launch needs to produce evidence before the team moves on.

Grok Bot can now add events, set reminders, and even turn off your lights for you

Grok can read and send messages, use location, manage calendar events and reminders, handle contacts, and control Home, with a separate Allow button for each app. That lets someone enable reminders without granting message access, a useful boundary when an assistant can both inspect information and take actions. What catches my attention is the unanswered scope of each permission: the article doesn’t say whether sending a message or locking a door requires any further confirmation.

The Rise and Fall of Jev

The article’s strongest engineering point is that Jev’s schema-valid output isn’t evidence of a correct decision. It says conventional language models can get the same constraint through a type checker or JSON-schema parser, while Jev does it faster and without reasoning. I like the distinction: there may be something useful under the hype, especially where local execution or speed matters, but those advantages don’t establish quality for your task. I’d evaluate it against real inputs and error costs, not its claim that it can’t hallucinate.

Feng Shui for Robots: The Fly MCP Server

Keeping the agent’s sandbox and production target on Linux avoids a runtime rewrite: Sprites retain files across restarts and run services. The Fly MCP server can create a Machine, volume, and secrets, while the agent brings knowledge of what it configured. Fly says there’s no universal promotion flow because each Sprite can contain a different project. I like that honest boundary; the remaining question is whether the agent can account for production requirements beyond its setup.

Physicists Trap a Single Antimatter Particle For a Month

Keeping a positron for a month depends on a container with no walls: electric fields confine it vertically, magnetic fields at the sides, in an ultracold vacuum. I can see why that setup sounds remarkable; it makes a particle that risks annihilation during handling available for measurement over time. The team plans to compare its magnetic moment with the electron’s, testing a precise Standard Model prediction. The trap enables that comparison, but the article reports the positron measurement as future work.

Is this the new cyber normal?

The hard part here is less whether LLMs change vulnerability research than whether maintainers, vendors, and operators can coordinate before a patch is usable. The PHP disclosure timeline shows how leaks and premature fixes can compress response into hours; AWS also reported seeing probing before those leaks, so better disclosure alone won't close the window. I’m probably in the author’s naive camp: coordinated security work is hard, but treating rapid exploitation as normal leaves no acceptable alternative. Teams need plans that assume exposure without giving up on improving coordination.

Rivian buys world model startup to accelerate self-driving ambitions

Proposal: Rivian's bet is to combine Third Dimension's AI-generated 3D worlds with real driving data, so its simulator can cover complex conditions before rare edge cases occur. The company says its customer fleet uploads more than 400,000 driving sequences daily. What catches my attention is whether generated scenes preserve the details needed for reliable validation; as more companies pursue autonomy, this is a world-model approach worth watching.

Introducing the Gemini API CLI

For shell-capable agents, gemini-api makes the interface inspectable before a request runs: –help, machine-readable –usage, –schema, and offline –dry-run expose commands and validate calls. Media commands write files to disk and emit only paths, while JSON, toon, and –jq keep results parseable, avoiding throwaway SDK scripts and base64-heavy context. I like that it treats output shape and offline validation as part of the agent interface, not an afterthought. Because the preview's command surface is still changing, I'd test those contracts before building a durable workflow around them.

#Agents #AI #Developer #Infrastructure

#infrastructure #developer #ai #agents

Search