Somad Albasit

Remisier |
Trader |
Investment Consultant |

[Somad Albasit @Somad_Albasit]

Apa ke benda program ni? Aku nak derma je, tapi pe hal boleh belajar sekali.

[Daniel Ch @chddaniel]

https://t.co/P8t2P4ilhb

[Roan @RohOnChain]

Jev is the FASTEST AI model ever built for trading

It makes calibrated buy/sell decisions in under 100 ms

That is one real decision on every single block, 24/7

In this article I've shown EXACTLY how to build HFT trading system with Jev (from scratch) https://t.co/4hmZDzN00Z

[codila @0xCodila]

Jev is the "Internet" moment for the AI industry

It tells your agents and LLMs what to do next, in milliseconds and at almost zero cost

If you set it up correctly, you will have the AI engineer’s stack for 2028

In this article, I show you how https://t.co/x3qn41ejnr

[Jina AI @JinaAI_]

Announcing jina-ocr-v1, our new visual document parser with 3.4B total parameters and 570M active parameters, with speculative decoding built in. Throw PDFs, scans, tables, charts, or invoices at it and get clean markdown back. Available on 🤗 & Jina Reader `x-respond-with` today

[沐阳 @yyyole]

视频自媒体刚需！这篇教程要收好！！
AI自动剪辑，然后自动排期发布，一整套！！

Astra + 达芬奇MCP，是目前最可能实现“AI自动剪辑成片直接能用”的组合技！！
至少比那些所谓的“自动剪辑插件”要好的多！

整个流程里，Astra 理解需求，通过 DaVinci Resolve MCP 操作剪辑软件，配套的 editing skills 则提供具体的剪辑思路。

教程使用的是开源的第三方 MCP，搭建时需要根据自己的电脑和达芬奇版本检查配置。
连接好之后，先确认AI打开的项目正不正确，确认后，再开始处理素材。
然后把各种素材放进同一个文件夹，然后告诉 AI：
你卖什么、视频给谁看，以及希望别人看完之后做什么。

不要着急出片！
几乎所有的视频教程，都会说到这个！
如果实际用AI生成过这种落地视频，就应该有体会！！
先做一小段，确定画面、字体、音效等符合自己的要求，然后再开始下一步，如果有调整，及时给参考图让AI修正。
这会少走很多弯路，也会节约不少Token！

成片完成后，教程可以通过 Blotato 自动排期发布，自此就完成了整个流程。
这套工作流倒是不算很新鲜，不过对于有店铺、或者有固定品牌需要视频营销的人来说，真的非常实用！
因为很多东西都是可复用的！品牌资料、确认过的风格都留在文件夹里，下次上新品、换菜单、做活动，再补充新素材和新需求。

文中用到的 达芬奇MCP 已经开源了，值得研究一下：
https://t.co/r0ogiUeugy

[Roan @RohOnChain]

i turned GPT-6 Astra into a 24/7 trading agent

here is the EXACT way to build your FIRST AI trading bot with GPT-6 Astra with COMPLETE ARCHITECTURE

GPT-6 Astra is most powerful trading agent ever built

the goal was simple - ship hedge fund grade trading strategies with a multi-agent team of quants

every layer solves one specific failure mode i hit in earlier versions:

1. reasoning substrate - GPT-6 Astra with 1M context, hours of long-horizon reasoning, direct computer use, and mathematical capabilities

2. harness layer - AgenKit installs 10 specialist agents inside Codex CLI. Conductor, Backend Architect, Test Engineer, Code Reviewer, Data Engineer, Debugger, Frontend, Infra DevOps, Perf Observability, Security. same model, TEN DISCIPLINES

3. workflow gates - 6 phases with operator approval at every step. brainstorm, architecture, plan, build, review, ship. nothing writes code until you sign off on the spec

4. mathematical foundation - 4 models running in production. Ornstein-Uhlenbeck stat arb, Avellaneda-Stoikov market making, Hawkes order flow, Heston volatility

5. production architecture - 6 layers wrapping every strategy. data, signal, decision, risk, execution, monitoring. the 2 AM WebSocket disconnect can no longer silently kill the model

6. risk enforcement - Kelly-sized positions, 5% drawdown kill switches, delta-neutral hedging, intent blotter output. these numbers came from watching an earlier chatbot script blow through 12% in one session

7. validation gates - every strategy must pass Sharpe above 1.5, drawdown below 15%, hit rate above 55%, t-stat above 2.0, walk-forward across 5 years before any capital touches it

8. output layer - Telegram Bot pings my phone with instrument, strategy, Sharpe, drawdown, action window and Kelly-sized position

the principle i built around from day one

> capability without structure is a chatbot
> the wall was never the math, it was always the six salary team

i learned that one the hard way

[Tom Dörr @tom_doerr]

Tracks real-time stock prices and sends personalized alerts while visualizing market data through interactive heatmaps

https://t.co/oXNrS2mbOK

[Quant Science @quantscience_]

12 Python libraries for free market data everyone should know:

[Kirk Borne @KirkDBorne]

Mathematics for Trading — 151 Strategies (download open-access 361-page PDF): https://t.co/OJ1X9QH2JB

[Diogo Almeida @CompleteSkeptic]

After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?

I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev

• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions

AFAICT the shortest path to AI-based economic revolution

[rewind @rewind02]

GPT-6 Astra + Obsidian is honestly the closest thing to a real second brain for a business...

i built a memory system that gives every agent instant context on what i've actually worked on, no re-explaining, no re-prompting:

- every project, decision and experiment gets logged as its own memory, timestamped automatically
- a 3D graph where the freshest, most-connected work sits in the center, the rest fades to the edges
- agents read the graph before doing anything, so outputs come back personalized instead of generic
- any agent i run (Claude, Codex, Kimi, GLM, whatever's next) writes to the same files, fully model-agnostic
- pick a cluster of memories and turn them straight into an output... an app, an SEO article, a full social thread
- the loop closes itself: use an agent, it logs the work, the next agent reads it, nothing gets forgotten

it's just markdown folders under the hood, which is exactly why it survives every model swap

full breakdown in the article below:

[NO1ennn @N01ennn]

this is f*cking gold

Google engineers explained how to make AI rewrite an agent’s system prompt against failing tests. a failed check becomes the next repair job. the regression suite watches for whatever that repair breaks.

even the instructions become something you can test and improve.

Agent = Model + Harness.

the independently compiled page here maps the broader system into six parts:

guides carry project rules, constraints and lessons from past failures

> sensors check the work through tests, linters and validators
> the loop runs the task, checks the result, retries within limits and escalates
> memory preserves state, artifacts and decisions across runs
> permissions control tools, writes and actions requiring approval
> observability records what happened, what it cost and where it failed

an agent changes a build file and announces “done.”
the check looks for evidence that it actually ran the validator.

if that behavior is missing, you have a specific failure to target. adjust the instructions. rerun the evaluations. check whether the improvement holds without breaking existing behavior.

now a prompt change has a test history. a recurring mistake has a regression check. the next model upgrade has something concrete to pass.

bookmark the diagram. give “done” a test it has to pass.

[chuplung @choopyplug1]

Anthropic just dropped a 13-page PDF on Agent Memory - 5 layers that cut token cost 90% and make your agent actually learn:

here's the 5-layer memory architecture:

layer 1 → working memory - the context window. everything the agent sees right now. when it fills up, old context dies. most agents stop here and wonder why they're broken

layer 2 → episodic memory - what happened. full interaction logs with timestamps. the agent recalls that the deploy failed Tuesday at 3am because the migration script had a typo

layer 3 → semantic memory - what is true. facts, entities, relationships stored as a knowledge graph. "user prefers TypeScript" lives here. doesn't expire when the session ends

layer 4 → procedural memory - how to do things. the agent tried 3 approaches, one worked. that method becomes a reusable skill. next time it skips straight to what worked

layer 5 → forgetting - what to delete. an agent that never forgets accumulates contradictions. old preferences override new ones. the user moved cities but the agent still recommends restaurants in the old one

the result: Mem0 stores 1,800 tokens per query instead of 26,000. Snowflake added one ontology layer - 20% better accuracy, 39% fewer tool calls. memory pays for itself on day one

this 13-page PDF is what separates a chatbot from an agent that actually learns

don't scroll past this one ↓

[Hassan @nutlope]

Introducing Inspo.

A design MCP server for Claude Code, Codex, and OpenCode.

It searches 800+ beautiful websites and finds relevant design inspiration for your coding agent.

Install → npx inspo-mcp install

[Roan @RohOnChain]

GPT-6 Astra builds the MOST POWERFUL 24/7 trading agents

i wrote a 6-page research paper on exactly how to use GPT-6 Astra at its FULLEST potential to build mathematical trading strategies like hedge funds

along with COMPLETE CODEBASE

here is how you set it up:

1. the 4 mathematical trading models every hedge fund runs. Ornstein-Uhlenbeck stat arb, Avellaneda-Stoikov market making, Hawkes order flow, Heston volatility. exact formulas for each

2. the exact validation thresholds. Sharpe above 1.5, drawdown below 15%, hit rate above 55%, t-stat above 2.0, walk-forward across 5 years

3. why the math was never the wall. the wall was the 6 salary team at $1.8M annual cost per model. Astra covers every role

4. the AgenKit harness that installs 10 specialist agents inside Codex CLI with test-first builds and two-stage review gates

5. the 6 layer production architecture with Kelly-sized positions, 5% drawdown kill switches and delta-neutral hedging

6. the exact one-line prompt that ships a working mathematical model like hedge funds in one weekend

this is the EXACT system i have been running for the past 5 days & results are INCREDIBLE so far:

[beamnxw ./ @beamnxw]

this is the most useful gpt-6 astra map on the internet today

i turned the entire use cases article into one operational field guide

19 application patterns

open it to see where agents fit and where traditional automation starts breaking

11 industry workflows

support, sales, finance, commerce, coding, marketing, all mapped

one instruction goes in, one completed result comes out

7 questions tell you if the workflow is worth building

exceptions go to the agent, final decisions stay with the human

start with the workflow, then decide where astra belongs

save this, then select your gpt-6 astra use case ⭣

[Kun Chen @kunchenguid]

many people reported astra draining quota way too fast

i ran an empirical study to quantify this for us. now here's some hard data -

1. in terms of "how many $ of tokens do you get from 1% of weekly quota", astra and sol aren't meaningfully different, so OpenAI is not "cheating" or anything

they both give around $13-15 per 1% of weekly quota on the $200 plan (btw this also shows you the month value of the subscription is ~$6000)

2. however, astra works much faster than sol while being way more expensive in terms of pricing. these two factors compound into a 2x faster drain on your quota

the study was done by running codex cli on the same repeated tasks in 8 open source repos, and measured all the stats. both models ran at medium reasoning

so my recommendation: don't use astra as the default for everything - it will cost you. use it only when you do need the extra intelligence, or you want something done fast

[Somad Albasit @Somad_Albasit]

@thsottiaux Love to get the banked reset...last night eventhough usage still 12%, but suddenly got rate limiting error

[Somad Albasit @Somad_Albasit]

@thsottiaux @thsottiaux seems i cant select PRO thinking in chatgpt chat..i already subscribe to chatgpt PROlite

[Somad Albasit @Somad_Albasit]

@thsottiaux @thsottiaux seems there is a bug in chatgpt chat, i cant select PRO level of thinking despite i'm a PRO lite users.