Apple, iOS 26.5’in ilk beta sürümünü yayınladı. Ancak, Gemini destekli yapay zeka özellikleri, ne de yeni Siri güncellemeye dahil edilmedi. Anlaşılan Apple, sürprizi iOS 27’ye saklıyor.
ChatGPT, Gemini ve Claude gibi bilinen ve yetenekleriyle şaşırtan en iyi yapay zeka uygulamaları listesi burada! İşte tek komutla harikalar çıkartan yapay zeka siteleri:
İtalya Donanması, Bayraktar TB3 SİHA’yı Cavour uçak gemisine entegre etmeye hazırlanıyor. Bayraktar TB3’ün keşif, gözetleme ve silahlı görevlerde kullanılması planlanıyor.
BYD, 2026 için ihracat hedefini 1,5 milyon araca yükseltti. 2025’te rekor satışlarla Tesla’yı geride bırakan Çinli üretici, uluslararası pazarlarda büyümesini sürdürüyor.
Bu hafta gelen açıklamalar, Disney’in Epic Games’i satın alma ihtimalini değerlendirdiğini gösteriyor. Epic tarafında yaşanan finansal sıkıntılar, bu söylentilere farklı bir boyut kazandırıyor.
Google, Android Auto işletim sisteminin kullanıldığı tamamen elektrikli araçlar için Maps (Haritalar) temelli bir şarj güncellemesi yayımladı. “Google Maps’in elektrikli araç şarjına yönelik yapay zeka destekli özelliklerini Android Auto temelli 350’den fazla araç modeline getiriyoruz.” diyen Google, bu konuda yaptığı resmi açıklamada, “Artık Haritalar, elektrikli araç modelinize ve batarya doluluk oranınıza göre ne zaman ve nerede şarj etmeniz gerektiğini söyleyecek; böylece hem yolda kalma korkunuz bitecek hem de farklı uygulamalarla uğraşmak zorunda kalmayacaksınız.” ifadelerine yer verdi. 15’ten fazla markaya ait yüzlerce elektrikli araç modeline açılan altyapı, ilk olarak ABD’de sunuluyor. “Yüzlerce aracın batarya tüketimini doğru tahmin edebilmek adına yapay zekayı gelişmiş enerji modelleriyle birleştiriyoruz. Bu modeller; aracın ağırlığı ve batarya boyutu gibi teknik özelliklerin yanı sıra haritalardan gelen trafik, yol eğimi ve hava durumu gibi gerçek zamanlı verileri de analiz ediyor.” diyen Google, sistemi önümüzdeki dönemde küresel olarak da kullanıma alabilir.
Google, Android Auto temelli elektrikli araçlar için Maps temelli bir şarj güncellemesi yayımladı yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.
Microsoft 365 Copilot’un doğrudan kompleks görevlere odaklanan Researcher aracı, “Critique” ve “Council” adı verilen yeni özelliklerle güçlendirildi. Microsoft CEO’su Satya Nadella tarafından yapılan paylaşıma göre yeni çok modelli derin araştırma sistemi Critique, birden fazla yapay zeka modelinin (GPT ve Claude) bir arada çalıştırılarak olabilecek en ideal sonuçların/raporların elde edilmesine aracılık ediyor. Council ise kullanıcıların aynı istem (prompt) üzerinde birden fazla modeli eş zamanlı olarak çalıştırmasına imkan tanıyor. Bu özellik farklı modellerin hangi noktalarda birleştiğini, hangi noktalarda ayrıştığını ve her bir modelin sonuca katkısını gözler önüne seriyor. Introducing Critique, a new multi-model deep research system in M365 Copilot. You can use multiple models together to generate optimal responses and reports. pic.twitter.com/m4RlQmCKzs — Satya Nadella (@satyanadella) March 30, 2026 New in M365 Copilot: Council. You can run multiple models on the same prompt at the same time, so you can see where they align and diverge, and understand what each adds. pic.twitter.com/2p7O14OLFp […]
Microsoft 365 Copilot’un Researcher aracı “Critique” ve “Council” özellikleriyle güçlendirildi yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.
Linux still lacks a reliable, native biometric authentication system.
While platforms like Windows and macOS have tightly integrated face authentication, Linux users typically rely on passwords — or experimental tools that often break under real-world conditions.
I wanted something:
So I built AstraLock.
AstraLock is a Linux biometric authentication system that enables face-based login through PAM and systemd, designed to be offline, auditable, and hackable, offering a native Linux alternative to projects like Howdy and closed platforms such as Windows Hello without cloud dependencies.
It runs a local daemon that performs facial verification and integrates directly with system authentication flows such as sudo, login, display managers, and polkit.
A system daemon that performs face verification
A PAM module (pam_facelock.so) for system authentication
A CLI tool for enrollment, verification, and testing
A local-only LBPH model (no cloud, no network)
No external services.
No telemetry.
No vendor lock-in.
login, sudo, polkit, display managers)pamtester
…
The Problem with Existing Approaches
Most existing solutions (like Howdy) work — until they don’t.
Common issues:
sudo, login, and display managersThe biggest issue wasn’t the ML part — it was system integration.
Design Goals
Before writing code, I defined strict constraints:
High-Level Architecture
Instead of embedding everything inside PAM, I separated concerns:
Application (sudo / login / GUI)
↓
PAM
↓
pam_facelock.so
↓
facelockd (systemd service)
↓
UNIX socket IPC
↓
Face recognition pipeline
Why this design?
PAM modules should stay minimal and predictable.
Heavy operations like:
are handled by a separate daemon.
This avoids blocking PAM and improves reliability.
Recognition Pipeline
The pipeline uses modern ONNX-based models:
Everything runs locally.
No external APIs. No network calls.
Key Challenges
1. PAM Behavior is Subtle
The biggest issue was handling:
auth sufficient vs required
Small changes in PAM configuration can completely change outcomes.
2. Display Managers Are Inconsistent
GDM, SDDM, and others:
This required testing across environments.
3. Camera Reliability
Accessing /dev/video* sounds simple — but:
4. Avoiding Lockouts
Biometric authentication is probabilistic.
So:
Current Capabilities
sudo, login, and GUI prompts (polkit) Security Considerations
This is not meant to replace passwords entirely.
Important points:
The system is designed for:
convenience + controlled risk, not absolute security
What I Learned
Looking for Feedback
I’m particularly interested in input on:
Project
AstraLock is open source and still evolving.
If you’ve worked with PAM, Linux auth, or system-level tooling, I’d appreciate your perspective.
Your Bayut scraper just broke again.
They updated their HTML. Your regex is wrong. The IP got blocked. You’re debugging at midnight instead of shipping.
Sound familiar?
I’ve been there. I built a scraper for Dubai property data. It worked for two months. Then Bayut updated their site. I spent a week fixing it. Then it broke again.
That’s when I found a better way.
The Problem with Scraping Bayut
Web scraping Bayut is painful for a few specific reasons:
The Solution: Bayut API
The Bayut API on RapidAPI gives you programmatic access to Bayut’s data without any of those problems.
Here’s what you can access:
Building the App: Step by Step
Let’s build a Dubai property search app. I’ll use Node.js and Express for the backend.
Step 1: Get Your API Key
Sign up on RapidAPI and subscribe to the Bayut API:
https://rapidapi.com/happyendpoint/api/bayut14/
Step 2: Location Search
First, implement location autocomplete so users can search by area.
const axios = require('axios');
async function searchLocations(query) {
const response = await axios.get(
'https://bayut14.p.rapidapi.com/autocomplete',
{
params: { query, langs: 'en' },
headers: {
'x-rapidapi-host': 'bayut14.p.rapidapi.com',
'x-rapidapi-key': process.env.RAPIDAPI_KEY
}
}
);
return response.data.data.locations;
}
// Returns: [{ id, externalID, name, slug, adCount }]
// Use externalID for property search
Step 3: Property Search
Now the core search functionality:
async function searchProperties(params) {
const response = await axios.get(
'https://bayut14.p.rapidapi.com/search-property',
{
params: {
purpose: params.purpose || 'for-sale',
location_ids: params.locationId,
property_type: params.type || 'apartments',
rooms: params.bedrooms,
price_min: params.minPrice,
price_max: params.maxPrice,
sort_order: 'popular',
page: params.page || 1,
langs: 'en'
},
headers: {
'x-rapidapi-host': 'bayut14.p.rapidapi.com',
'x-rapidapi-key': process.env.RAPIDAPI_KEY
}
}
);
const { properties, total, totalPages } = response.data.data;
return { properties, total, totalPages };
}
Each property in the response includes:
Step 4: Property Details
When a user clicks a listing, fetch full details:
async function getPropertyDetails(externalId) {
const response = await axios.get(
'https://bayut14.p.rapidapi.com/property-details',
{
params: { external_id: externalId, langs: 'en' },
headers: {
'x-rapidapi-host': 'bayut14.p.rapidapi.com',
'x-rapidapi-key': process.env.RAPIDAPI_KEY
}
}
);
return response.data.data;
}
Step 5: Off-Plan Projects
Add a section for new developments:
async function searchOffPlan(locationId) {
const response = await axios.get(
'https://bayut14.p.rapidapi.com/search-new-projects',
{
params: {
location_ids: locationId,
property_type: 'residential',
sort_order: 'latest',
page: 1
},
headers: {
'x-rapidapi-host': 'bayut14.p.rapidapi.com',
'x-rapidapi-key': process.env.RAPIDAPI_KEY
}
}
);
return response.data.data.properties;
}
What I Built in 48 Hours
Using this API, I built a working property search app with:
/autocomplete)/search-property)/property-details)/search-new-projects)/agent-details)Total development time: 48 hours.
With a scraper, this would have taken 3-4 weeks – and it would break every month.
The Numbers
| Scraper | Bayut API | |
|---|---|---|
| Setup time | 3-4 weeks | 2 days |
| Monthly cost | $300-500 (proxies) | $10-50 |
| Uptime | ~70% | 99.9% |
| Maintenance | 10+ hrs/month | 0 hrs/month |
| Legal risk | High | None |
What to Build Next
Once you have the basics working, here are some features to add:
/transactions to show price trends Get Started
The Bayut API is available on RapidAPI with a free plan:
🔗 https://rapidapi.com/happyendpoint/api/bayut14/
Full documentation:
Questions? Reach out: [email protected]
Built by Happy Endpoint – developer-friendly APIs for real-world data.
🌐 https://happyendpoint.com | 🐦 https://x.com/happyendpointhq
Modern AI agents are no longer just generating text—they are expected to write files, modify code, and execute commands.
But doing this directly on your local machine or production systems is risky and hard to control.
This is where AIO Sandbox comes in.
It provides an isolated, programmable environment where agents can safely:
create and manipulate files
run shell commands
execute code
produce artifacts
In this first post, we’ll focus on the two most fundamental capabilities:
🧩 Filesystem (state)
⚙️ Shell (execution)
By the end, you’ll see how these combine into a complete runtime for agents.
🌐 Multi-language SDK Support
While this tutorial uses Python, AIO Sandbox is not limited to Python developers.
The agent-sandbox SDK also supports:
TypeScript / JavaScript
Go (Golang)
👉 This makes it easy to integrate AIO Sandbox into a wide range of agent frameworks, backend services, and developer stacks.
🛠️ Prerequisites
Python 3.12+
A running AIO Sandbox instance at http://localhost:8080
Python SDK installed
pip install agent-sandbox
🧠 Mental Model
Think of AIO Sandbox as a remote, disposable Linux machine that your agent controls via APIs.
Filesystem → where data and artifacts live
Shell → how actions are executed
Simple Flow:
Agent → API → Sandbox → Filesystem + Shell
📁 Part 1 — Working with Files
Let’s start by treating the sandbox like a filesystem.
1.Hello Sandbox Files
Goal: introduce write_file, read_file, and list_path.
from agent_sandbox import Sandbox
client = Sandbox(base_url="http://localhost:8080")
home_dir = client.sandbox.get_context().home_dir
notes_file = f"{home_dir}/hello.txt"
# Write a text file
write_result = client.file.write_file(
file=notes_file,
content="Hello from AIO Sandbox!nThis file lives inside the sandbox.",
)
print("Wrote bytes:", getattr(write_result.data, "bytes_written", None))
# Read it back
read_result = client.file.read_file(file=notes_file)
print("File content:")
print(read_result.data.content)
# List files in the sandbox home directory
list_result = client.file.list_path(
path=home_dir,
include_size=True,
sort_by="name",
)
items_to_list = getattr(list_result.data, 'files', getattr(list_result.data, 'entries', []))
for item in items_to_list:
print(f"- {item.path} ({getattr(item, 'size', 'unknown')} bytes)")
2.Edit a Config File
Goal: show replace_in_file and search_in_file.
💡 Agents often follow a loop:
modify → verify → proceed
from agent_sandbox import Sandbox
client = Sandbox(base_url="http://localhost:8080")
home_dir = client.sandbox.get_context().home_dir
config_file = f"{home_dir}/app.env"
# Create a simple config file
client.file.write_file(
file=config_file,
content="MODE=devnPORT=8000nDEBUG=truen",
)
# Replace one value
client.file.replace_in_file(
file=config_file,
old_str="MODE=dev",
new_str="MODE=prod",
)
# Search to verify
search_result = client.file.search_in_file(
file=config_file,
regex=r"MODE=.*",
)
print("Search result:")
print(search_result)
# Read final content
final_file = client.file.read_file(file=config_file)
print("nUpdated config:")
print(final_file.data.content)
3.Write and Export an Artifact
Goal: show download_file.
sandbox outputs can be streamed out cleanly
useful for logs, reports, generated code, screenshots, notebooks, datasets
home_dir = client.sandbox.get_context().home_dir
report_file = f"{home_dir}/report.txt"
# Create an artifact inside the sandbox
client.file.write_file(
file=report_file,
content="Run completenStatus: successnArtifacts generated: 1n",
)
# Download it from the sandbox to the local machine
with open("downloaded_report.txt", "wb") as f:
for chunk in client.file.download_file(path=report_file):
f.write(chunk)
print("Downloaded sandbox artifact to ./downloaded_report.txt")
4.Discover files
result = client.file.find_files(
path=home_dir,
glob="*.txt",
)
print(result)
⚙️ Part 2 — Executing Commands (Shell)
Now let’s make the sandbox do work.
⚠️ Important Notes
exec_command(command="...")
result.data.output
result.data.exit_code
1. Basic shell command execution (Hello World)
from agent_sandbox import Sandbox
client = Sandbox(base_url="http://localhost:8080")
result = client.shell.exec_command(
command="echo 'Hello from sandbox shell'"
)
print("Output:", result.data.output)
print("Exit code:", result.data.exit_code)
2. Inspect the sandbox environment
result = client.shell.exec_command(command="pwd")
print("PWD:", result.data.output)
result = client.shell.exec_command(command="ls -la")
print(result.data.output)
👉 The sandbox behaves like a real Linux environment.
3. Execute a Python script
home_dir = client.sandbox.get_context().home_dir
script_path = f"{home_dir}/hello.py"
client.file.write_file(
file=script_path,
content="""
print("Running inside sandbox")
print("Computation:", 10 * 5)
""",
)
result = client.shell.exec_command(
command=f"python3 {script_path}"
)
print(result.data.output)
🔥 This is an important pattern:
Agent writes code → executes it → observes output
4. Install and use a package
# Install package
client.shell.exec_command(command="pip install requests")
# Verify installation
result = client.shell.exec_command(
command='python3 -c "import requests; print(requests.__version__)"'
)
print("Requests version:", result.data.output)
💡 Shows:
sandbox is mutable
supports dynamic dependencies
5. Chain commands
result = client.shell.exec_command(
command="mkdir -p demo && echo 'hello' > demo/file.txt && cat demo/file.txt"
)
print(result.data.output)
6. Check exit codes
result = client.shell.exec_command(command="ls non_existent_file")
print("Output:", result.data.output)
print("Exit code:", result.data.exit_code)
Agents should check exit codes, not just output.
🧩 Bringing It Together
At this point, we’ve seen:
Filesystem (state)
Core primitives to showcase:
create
read
modify
search
list
discover
Shell (execution)
Core primitives to showcase:
run commands
execute scripts
inspect environment
🎯 Key Insight
AIO Sandbox gives agents a safe, programmable runtime:
Files → memory/state
Shell → actions
Together, they enable real-world workflows like:
code generation and execution
data processing
automation pipelines
tool orchestration
🚀 What’s Next
Thanks for reading! Hope it was helpful! This is just the beginning. In upcoming posts, we’ll dive into topics such as:
🌐 Browser automation (CDP-based)
🔌 MCP tool integration
📓 Jupyter / notebook execution
🤖 OpenClaw integration
🎯 Reinforcement learning inside sandbox
💬 Final Thoughts
AIO Sandbox bridges the gap between:
“LLM that generates text”
and
“Agent that can actually do things”
And it does so safely, reproducibly, and programmatically.