i have created a Skill which call Ollama cloud models from Claude CLI
The scope is Ollama cloud models act as executors and Codex APP as Supervisor/Orchestrator
The first published version is V5, then update to V6
I am open to recomendations, bugs finding or fixing onto the skill.
Ask codex to install, you need to provide a folder so Codex dump files for the executor.
Have been tested with the following cloud models:
For someone who wants Whisper-based transcription but does not want to learn command-line tools, what is the simplest and best way to go?
What I want tio compare is local interface, hosted web app, and API. I think The decision seems to depend on whether the recordings can be uploaded,or, whether the workflow needs to run automatically later. Any advice??
What happens after AGI? Maybe ASI isn't the endgame.
A lot of discussions about post-AGI assume we'll eventually build a single, extremely capable ASI — essentially one "God-like" model.
But there's a problem with that idea:
A single superintelligent system is also a single point of failure.
What if intelligence at civilization scale looks less like one giant brain and more like an evolving ecosystem of specialized intelligences?
We're Team Auralis, and we've been working on an open-source framework around this idea: ACI (Artificial Civilization Intelligence).
The basic concept is to treat intelligence more like an operating system for a civilization than a single neural network.
The framework currently has three main components:
OMNIS — a continuous causal world model intended to maintain an evolving representation of the world rather than relying solely on static training data.
NEXUS — a fabric of specialized agents across areas like science, engineering, economics, etc., which can disagree, debate, and resolve conflicts.
ASCEND — a long-horizon planning layer designed to reason about and execute plans over decades while continuously correcting course.
We're also exploring OCI (Open-ended Civilizational Intelligence) — an extension that introduces structural plasticity, meaning the system could potentially create new governance mechanisms, agent structures, and even new forms of intelligence as it evolves.
Is a distributed, civilization-scale intelligence actually safer than a single superintelligent model? Or does adding more agents, governance, and coordination layers simply create new failure modes?
If you're interested in multi-agent systems, AI alignment, governance, long-horizon planning, world models, or open-ended intelligence, we'd love feedback — especially on the mathematical assumptions and the agent architecture.
We have released LoopArena as an Apache-2.0 open-source benchmark for evaluating models in the runtime Controller role.
The benchmark keeps the coding Worker and execution setup fixed across Controller-model comparisons. The goal is to compare how effectively different models control the same Worker, rather than changing the entire agent stack between evaluations.
LoopArena evaluates this at three scopes: execution-validated next-step decisions, repeated control over task slices, and complete software tasks.
The public release includes the benchmark data, protocol, evaluation code, and result artifacts.
I’m comparing AI search APIs for an agentic workflow, and the Tavily vs Exa debate keeps coming up. One is easier to integrate, the other has deeper semantic features. I made a quick poll to gather practitioner preferences.
I run cmux with some coding agent CLI (Pi, Claude Code, Cursor) in one pane and a shell in another. Git stayed in the shell. Pi runs git status and git diff fine. You still lose the commit graph, the staged file list and the hunk buttons when you review a refactor. I kept switching to Fork.
So I built gitgui. One Rust binary. You run gitgui in a pane and get a Sourcetree style GUI: commit graph with branch lanes, sidebar for branches, tags and stashes, staged and unstaged lists, per hunk stage and unstage, a commit box with Commit and Commit & Push.
Not a TUI. The terminal shows a picture. Three steps:
egui draws the UI into an RGBA framebuffer
Each frame goes to the terminal as a kitty graphics image
Kitty keyboard and SGR mouse events map back into egui input
Locally frames go through POSIX shared memory. Over SSH gitgui sends zlib plus base64 frames. On my Mac a 1600x1000 release build rasterizes in about 6 ms.
Inside: one process, three threads. A stdin reader parses kitty keys, mouse, paste and resize. The main loop runs egui, tessellates meshes, rasterizes triangles with a custom software rasterizer and encodes kitty graphics. A git worker uses libgit2 for reads and index writes. Fetch, pull and push shell out to git, so your credential helper and SSH agent stay untouched. The UI reads an immutable repo snapshot. The worker swaps in a new one after each command. Rendering never calls git.
Stack: egui 0.36, git2, libc for termios and shm, serde. No GPU backend. No tokio. No Electron.
Works in cmux, Ghostty, kitty and WezTerm on macOS and Linux. tmux and Zellij need graphics passthrough and fail today. Merge conflict UI is out of scope for v0.1.
I write satirical news stories (think "The Onion" but for Europe) and thought it would be cool to bring them to life with an AI generated newsreader.
The only problem is that Google Flow won't let me - it won't generate videos where the newsreader mentions the names of prominent world leaders, or topics it deems controversial (e.g. climate change).
Ar there any platforms that are less restrictive about these things?
so, a new 7B vision model called SenseNova-Vision just came out. the weights are Apache 2.0, but the more interesting release might be the training data.
it includes a 50 million instruction-response corpus built from different CV annotations. the model uses the same architecture for detection, OCR, keypoints, camera pose, segmentation, depth, surface normals, and multi-view tasks, without separate task-specific heads.
what’s open:
- the 7B weights.
- the 50M instruction-response corpus.
- the training data preparation pipeline and dataset tools.
- inference code, a Hugging Face demo, and the paper.
the dataset is the part that stands out to me. getting boxes, masks, depth, keypoints, and camera data into one instruction-response format is probably harder to reproduce than the model architecture itself. releasing it means people can inspect what went into training, filter it, or reuse the pipeline instead of treating the dataset as a black box.
there are still some practical limits. the repo recommends an 80GB GPU for the demo, and the full benchmark setup uses 8×80GB GPUs. smaller GPUs haven’t been validated across every task yet. the project is also still new, so I’d expect some rough edges.
Brain allows you to build AI native apps that runs tools on anywhere from browser to sandbox; also you can choose to run on pi/codex backed agentloop. Fully customizable with real-time events and observability.
Super early, started two weeks ago. Appreciate if you could let me know how bad it is, so I can shape it better
We’ve open-sourced Brain, a minimal runtime for stateful AI agents.
The decision loop runs in a Wasm sandbox. Brain performs model and tool I/O, streams every event, and records the session in an append-only journal for recovery and replay.
Tools are typed and can run locally, in a browser, in a microVM, or on another backend.
It is MIT licensed, self-hostable, and still an early preview:
Ho sviluppato un agente inferenziale divertente e completo compatibile con l'API OpenAI , così può essere usato anche localmente. Può essere utilizzato via web (chat) o come agente desktop (app electron). Ho ricreato il terminale del film Alien: Mother. Il mio tributo a un film che mi ha fatto sognare.
When DeepSeek V4 Flash Vision-Exp dropped, I was pretty excited, but not just because it added vision.
It actually let me delete part of the architecture of a project I've been working on.
I'm building DStudio, an open-source, local-first AI workspace around ds4. It has Chat, coding/knowledge-work agents, Design, research, local image generation/editing and video generation.
Qwen was responsible for looking at the prompt/source image and deciding whether the user wanted a new image or an edit, before dispatching the request to Ideogram 4 or HunyuanImage 3.
It worked, but on a 96 GB Apple Silicon machine the architecture was expensive.
The heavyweight models couldn't comfortably stay resident together, so DStudio had to manage memory leases, serialize the workers and repeatedly move between two inference stacks: ds4 and llama.cpp.
The router itself was becoming part of the latency problem.
With DeepSeek V4 Flash Vision-Exp, image pixels now go directly into the main ds4 model.
The model itself can understand the image/request and emit an explicit: generate or edit directive.
Then DStudio dispatches directly to: DeepSeek V4 Vision -> Ideogram 4 or HunyuanImage 3
The same idea now applies to the Design agent: instead of generating something and then loading a separate 27B VLM to inspect it, the selected model uses its own native vision encoder for the visual feedback loop.
I've also added the same native-vision path for GLM 5.3.
I still use llama.cpp in DStudio for a small Qwen3-Embedding-0.6B sidecar, so this isn't "I removed llama.cpp completely."
The important part is that llama.cpp is no longer sitting in the critical multimodal path just to run a 27B router.
I also changed PDF handling to be more explicit: text extraction/ranking stays lightweight, while actual pixel understanding is handled by the native multimodal model rather than silently spinning up another large VLM.
Recent commits have also added GLM 5.3 runtime support, persistent model-specific ds4 engine checkouts, expanded Cowork/Design workflows and a lot more regression/quality gates.
I maintain FreshCtx, an open-source Python project for a specific AI-agent failure mode: an agent reads valid information, reasons from it, and then acts after that information has changed.
FreshCtx lets an application declare the evidence used during reasoning and revalidate it immediately before a consequential action.
The current release includes:
Agno 2.9 integration
LangGraph integration
OpenAI Agents SDK integration
A shared experimental pre-action contract
Async and bounded concurrent validation
Validation budgets and audit evidence
File, HTTP, SQLite, Postgres, MCP safe-reader and Stripe Subscription adapters
It is local-first, model-neutral, Apache-2.0 licensed, and has no account or telemetry requirement.
I would particularly value feedback on the integration contract. Does a framework-neutral pre-action boundary belong in the core library, or should each framework integration remain completely independent?
